package com.example.core.service.impl;

import com.example.core.dao.ProcessingDao;
import com.example.core.entity.*;
import com.example.core.service.ProcessingService;
import com.example.core.utils.RegionEnum;
import com.example.core.utils.SearchEnum;
import com.example.core.utils.TargetEnum;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.math.BigDecimal;
import java.util.*;
import java.util.stream.Collectors;

@Service("ProssingService")
public class ProcessingServiceImpl implements ProcessingService {

    @Resource
    ProcessingDao processingDao;

    @Override
    public Map<String, List<DealerForm>> getBaseForm(String yearId, String quarterId) {
        //查询DealerForm
        List<DealerForm> totalList = processingDao.queryDealerForm(yearId, quarterId);

        //时间范围内各季度经销商已填报数量
        List<DealerForm> dealerCount = processingDao.querytDealerCount(yearId, quarterId);

        //时间范围内各季度经销商已填报数量(按地区划分)
        List<DealerForm> regionDealerCount = processingDao.querytDealerCountByRegion(yearId, quarterId);

        //当前季度去重经销商
//        List<DealerForm> dealerList = totalList.stream()
//                .filter(x -> x.getQuarterId().equals(quarterId)).collect(Collectors.toList())
//                .stream().collect(Collectors.collectingAndThen(Collectors.toCollection(
//                        () -> new TreeSet<>(Comparator.comparing(o -> o.getJxsDealerId()))), ArrayList::new)
//                );
        List<DealerForm> dealerList = processingDao.queryDistincttDealer(yearId, quarterId);

        //新车
        List<DealerForm> car = totalList.stream().parallel()
                .filter(x -> "利润表".equals(x.getFormName()) && "新车销售".equals(x.getStatisTypeName()))
                .collect(Collectors.toList());
        List<DealerForm> carTemp = totalList.stream().parallel()
                .filter(x -> "新车销售业务明细".equals(x.getFormName()) && "合计".equals(x.getStatisTypeName()))
                .collect(Collectors.toList());
        List<DealerForm> carTempAddition = totalList.stream().parallel()
                .filter(x -> "新车销售业务明细".equals(x.getFormName()))
                .collect(Collectors.toList());
        //售后
        List<DealerForm> afterSale = totalList.stream().parallel()
                .filter(x -> "售后业务明细".equals(x.getFormName()) && "合计".equals(x.getStatisTypeName()))
                .collect(Collectors.toList());
        List<DealerForm> afterSaleTemp = totalList.stream().parallel()
                .filter(x -> "利润表".equals(x.getFormName()) && "维修保养业务".equals(x.getStatisTypeName()))
                .collect(Collectors.toList());
        //二手车
        List<DealerForm> usedCar = totalList.stream().parallel()
                .filter(x -> "利润表".equals(x.getFormName()) && "二手车销售".equals(x.getStatisTypeName()))
                .collect(Collectors.toList());
        //其他
        List<DealerForm> other = totalList.stream().parallel()
                .filter(x -> "利润表".equals(x.getFormName()) && "其他业务".equals(x.getStatisTypeName()))
                .collect(Collectors.toList());
        //合计
        List<DealerForm> total = totalList.stream().parallel()
                .filter(x -> "利润表".equals(x.getFormName()) && "合计".equals(x.getStatisTypeName()))
                .collect(Collectors.toList());

        //自费、保养、事故、索赔（charge service trouble claim）
        List<DealerForm> charge = totalList.stream().parallel()
                .filter(x -> "售后业务明细".equals(x.getFormName()) && "自费".equals(x.getStatisTypeName()))
                .collect(Collectors.toList());

        List<DealerForm> service = totalList.stream().parallel()
                .filter(x -> "售后业务明细".equals(x.getFormName()) && "保养".equals(x.getStatisTypeName()))
                .collect(Collectors.toList());

        List<DealerForm> trouble = totalList.stream().parallel()
                .filter(x -> "售后业务明细".equals(x.getFormName()) && "事故".equals(x.getStatisTypeName()))
                .collect(Collectors.toList());

        List<DealerForm> claim = totalList.stream().parallel()
                .filter(x -> "售后业务明细".equals(x.getFormName()) && "索赔".equals(x.getStatisTypeName()))
                .collect(Collectors.toList());

        Map<String, List<DealerForm>> resultMap = new HashMap<>();
        resultMap.put("car", car);
        resultMap.put("carTemp", carTemp);
        resultMap.put("carTempAddition", carTempAddition);
        resultMap.put("afterSale", afterSale);
        resultMap.put("afterSaleTemp", afterSaleTemp);
        resultMap.put("charge", charge);
        resultMap.put("service", service);
        resultMap.put("trouble", trouble);
        resultMap.put("claim", claim);
        resultMap.put("usedCar", usedCar);
        resultMap.put("other", other);
        resultMap.put("total", total);
        resultMap.put("base", totalList);
        resultMap.put("currentDealer", dealerList);
        resultMap.put("dealerCount", dealerCount);
        resultMap.put("regionDealerCount", regionDealerCount);
        return resultMap;
    }

    @Override
    public BigDecimal getBaseIndex(String yearId, String quarterId, RegionEnum regionEnum, String dealer,
                                   Map<String, List<DealerForm>> baseMap, SearchEnum searchEnum, TargetEnum targetEnum) {

        BigDecimal bigDecimal = new BigDecimal("0");
        switch (searchEnum.getSearchType()) {
            case "全国":
                bigDecimal = new BigDecimal(baseMap.get(targetEnum.getBaseMapKey()).stream().parallel()
                        .filter(x -> x.getYearId().equals(yearId)
                                && x.getQuarterId().equals(quarterId)
                                && x.getTargetName().equals(targetEnum.getBaseMapvalue()))
                        .collect(Collectors.summingDouble(x -> x.getTaegetVal().doubleValue())).toString());
                break;
            case "大区":
                bigDecimal = new BigDecimal(baseMap.get(targetEnum.getBaseMapKey()).stream().parallel()
                        .filter(x -> x.getYearId().equals(yearId)
                                && x.getQuarterId().equals(quarterId)
                                && x.getRegionName().equals(regionEnum.getRegionName())
                                && x.getTargetName().equals(targetEnum.getBaseMapvalue()))
                        .collect(Collectors.summingDouble(x -> x.getTaegetVal().doubleValue())).toString());
                break;
            case "经销商":
                bigDecimal = new BigDecimal(baseMap.get(targetEnum.getBaseMapKey()).stream().parallel()
                        .filter(x -> x.getYearId().equals(yearId)
                                && x.getQuarterId().equals(quarterId)
                                && x.getJxsDealerId().equals(dealer)
                                && x.getTargetName().equals(targetEnum.getBaseMapvalue()))
                        .collect(Collectors.summingDouble(x -> x.getTaegetVal().doubleValue())).toString());
                break;
            case "全国全年累计":
                bigDecimal = new BigDecimal(baseMap.get(targetEnum.getBaseMapKey()).stream().parallel()
                        .filter(x -> x.getYearId().equals(yearId)
                                && x.getTargetName().equals(targetEnum.getBaseMapvalue()))
                        .collect(Collectors.summingDouble(x -> x.getTaegetVal().doubleValue())).toString());
                break;
            case "大区全年累计":
                bigDecimal = new BigDecimal(baseMap.get(targetEnum.getBaseMapKey()).stream().parallel()
                        .filter(x -> x.getYearId().equals(yearId)
                                && x.getRegionName().equals(regionEnum.getRegionName())
                                && x.getTargetName().equals(targetEnum.getBaseMapvalue()))
                        .collect(Collectors.summingDouble(x -> x.getTaegetVal().doubleValue())).toString());
                break;
            case "经销商全年累计":
                bigDecimal = new BigDecimal(baseMap.get(targetEnum.getBaseMapKey()).stream().parallel()
                        .filter(x -> x.getYearId().equals(yearId)
                                && x.getJxsDealerId().equals(dealer)
                                && x.getTargetName().equals(targetEnum.getBaseMapvalue()))
                        .collect(Collectors.summingDouble(x -> x.getTaegetVal().doubleValue())).toString());
                break;
            default:
        }

        return bigDecimal;
    }

    @Override
    public NewCarIndex getCarCollectIndex(String yearId, String quarterId, DealerForm dealerForm, Map<String, List<DealerForm>> baseMap,
                                          RegionEnum regionEnum, SearchEnum searchEnum) {

        NewCarIndex entity = new NewCarIndex();
        BigDecimal zero = new BigDecimal("0");
        String dealerId = dealerForm.getJxsDealerId();
        String regionName = regionEnum.getRegionName();


        if ("".equals(regionName)) {
            if (dealerId != null) {
                entity.set经销商ID(dealerId);
                entity.set统计范围分类(0);//经销商
            } else {
                entity.set统计范围分类(4);//全国
            }
        } else {
            entity.set区域ID(regionEnum.getRegionId());
            entity.set统计范围分类(3);//大区
        }


        //获取基础指标
        BigDecimal 新车业务销售收入 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.新车业务销售收入);
        BigDecimal 新车业务销售成本 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.新车业务销售成本);
        BigDecimal 新车业务综合营业收入 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.新车业务综合营业收入);
        BigDecimal 新车综合营业成本 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.新车综合营业成本);
        BigDecimal 综合营业收入 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.综合营业收入);
        BigDecimal 新车业务返利 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.新车业务返利);
        BigDecimal 新车销售台次 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.新车销售台次);
        BigDecimal 新车业务衍生收入 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.新车业务衍生收入);
        BigDecimal 新车业务金融收入 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.新车业务金融收入);
        BigDecimal 新车业务其他衍生收入 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.新车业务其他衍生收入);
        BigDecimal 新车业务衍生成本 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.新车业务衍生成本);
        BigDecimal 新车业务保险收入 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.新车业务保险收入);
        BigDecimal 新车业务精品外销非原厂收入 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.新车业务精品外销非原厂收入);
        BigDecimal 新车业务精品外销非原厂台次 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.新车业务精品外销非原厂台次);
        BigDecimal 新车业务车贷佣金及手续费收入 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.新车业务车贷佣金及手续费收入);
        BigDecimal 新车业务车贷服务费及佣金台次 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.新车业务车贷服务费及佣金台次);
        BigDecimal 新车业务租赁佣金及手续费收入 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.新车业务租赁佣金及手续费收入);
        BigDecimal 新车业务融资租赁服务费及佣金台次 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.新车业务融资租赁服务费及佣金台次);
        BigDecimal 新车业务新保佣金收入 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.新车业务新保佣金收入);
        BigDecimal 新车业务新保台次 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.新车业务新保台次);
        BigDecimal 新车业务其他收入 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.新车业务其他收入);
        BigDecimal 新车业务其他收入台次 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.新车业务其他收入台次);
        BigDecimal 主营业务台次 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.主营业务台次);
        BigDecimal 新车业务各业务单元间接人工成本 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.新车业务各业务单元间接人工成本);
        BigDecimal 新车业务抵减后促销政策费用 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.新车业务抵减后促销政策费用);
        BigDecimal 新车业务其他可归属到业务的费用 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.新车业务其他可归属到业务的费用);
        BigDecimal 新车业务其他衍生成本 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.新车业务其他衍生成本);
        BigDecimal 新车业务各业务单元广告及市场费用 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.新车业务各业务单元广告及市场费用);
        BigDecimal 新车业务各业务单元财务费用 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.新车业务各业务单元财务费用);


        //汇总指标公式
        BigDecimal 新车业务毛利贡献率 = 综合营业收入.compareTo(BigDecimal.ZERO) == 0 ? zero :
                新车业务综合营业收入.subtract(新车综合营业成本).add(新车业务返利).divide(综合营业收入, 4, BigDecimal.ROUND_HALF_EVEN);
        entity.set新车业务毛利贡献率(新车业务毛利贡献率);

        BigDecimal 平均单车新车毛利Ⅱ = 新车销售台次.compareTo(BigDecimal.ZERO) == 0 ? zero :
                新车业务销售收入.subtract(新车业务销售成本).add(新车业务返利).divide(新车销售台次, 4, BigDecimal.ROUND_HALF_EVEN);
        entity.set平均单车新车毛利Ⅱ(平均单车新车毛利Ⅱ);

        BigDecimal 新车收入占比 = 综合营业收入.compareTo(BigDecimal.ZERO) == 0 ? zero :
                新车业务综合营业收入.divide(综合营业收入, 4, BigDecimal.ROUND_HALF_EVEN);
        entity.set新车收入占比(新车收入占比);

        BigDecimal 新车一级毛利率 = 新车业务综合营业收入.compareTo(BigDecimal.ZERO) == 0 ? zero :
                新车业务销售收入.subtract(新车业务销售成本).divide(新车业务综合营业收入, 4, BigDecimal.ROUND_HALF_EVEN);
        entity.set新车一级毛利率(新车一级毛利率);

        BigDecimal 新车二级毛利率 = 新车业务综合营业收入.compareTo(BigDecimal.ZERO) == 0 ? zero :
                新车业务销售收入.subtract(新车业务销售成本).add(新车业务返利).divide(新车业务综合营业收入, 4, BigDecimal.ROUND_HALF_EVEN);
        entity.set新车二级毛利率(新车二级毛利率);

        BigDecimal 新车业务平均单车返利 = 新车销售台次.compareTo(BigDecimal.ZERO) == 0 ? zero :
                新车业务返利.divide(新车销售台次, 4, BigDecimal.ROUND_HALF_EVEN);
        entity.set新车业务平均单车返利(新车业务平均单车返利);

        BigDecimal 平均单车衍生收入 = 新车销售台次.compareTo(BigDecimal.ZERO) == 0 ? zero :
                新车业务衍生收入.divide(新车销售台次, 4, BigDecimal.ROUND_HALF_EVEN);
        entity.set平均单车衍生收入(平均单车衍生收入);

        BigDecimal 三级毛利率 = 新车业务综合营业收入.compareTo(BigDecimal.ZERO) == 0 ? zero :
                新车业务综合营业收入.subtract(新车综合营业成本).add(新车业务返利).divide(新车业务综合营业收入, 4, BigDecimal.ROUND_HALF_EVEN);
        entity.set三级毛利率(三级毛利率);

        BigDecimal 平均单车三级毛利 = 新车销售台次.compareTo(BigDecimal.ZERO) == 0 ? zero :
                新车业务综合营业收入.subtract(新车综合营业成本).add(新车业务返利).divide(新车销售台次, 4, BigDecimal.ROUND_HALF_EVEN);
        entity.set平均单车三级毛利(平均单车三级毛利);

        BigDecimal 新车返利对新车利润贡献率 = 新车业务综合营业收入.compareTo(BigDecimal.ZERO) == 0 ? zero :
                新车业务返利.divide(新车业务综合营业收入, 4, BigDecimal.ROUND_HALF_EVEN);
        entity.set新车返利对新车利润贡献率(新车返利对新车利润贡献率);

        BigDecimal 金融衍生贡献 = 新车业务综合营业收入.compareTo(BigDecimal.ZERO) == 0 ? zero :
                新车业务金融收入.divide(新车业务综合营业收入, 4, BigDecimal.ROUND_HALF_EVEN);
        entity.set金融衍生贡献(金融衍生贡献);

        BigDecimal 保险衍生贡献 = 新车业务综合营业收入.compareTo(BigDecimal.ZERO) == 0 ? zero :
                新车业务保险收入.divide(新车业务综合营业收入, 4, BigDecimal.ROUND_HALF_EVEN);
        entity.set保险衍生贡献(保险衍生贡献);

        BigDecimal 其他衍生贡献 = 新车业务综合营业收入.compareTo(BigDecimal.ZERO) == 0 ? zero :
                新车业务其他衍生收入.subtract(新车业务其他衍生成本).divide(新车业务综合营业收入, 4, BigDecimal.ROUND_HALF_EVEN);
        entity.set其他衍生贡献(其他衍生贡献);

        BigDecimal 精品备件衍生贡献 = 新车业务综合营业收入.compareTo(BigDecimal.ZERO) == 0 ?
                zero.subtract(金融衍生贡献).subtract(保险衍生贡献).subtract(其他衍生贡献) :
                新车业务衍生收入.subtract(新车业务衍生成本).divide(新车业务综合营业收入, 4, BigDecimal.ROUND_HALF_EVEN)
                        .subtract(金融衍生贡献).subtract(保险衍生贡献).subtract(其他衍生贡献);
        entity.set精品备件衍生贡献(精品备件衍生贡献);

        BigDecimal 新车毛利Ⅰ对新车利润贡献率 = 新车业务销售收入.compareTo(BigDecimal.ZERO) == 0 ? zero :
                新车业务销售收入.subtract(新车业务销售成本).divide(新车业务销售收入, 4, BigDecimal.ROUND_HALF_EVEN);
        entity.set新车毛利Ⅰ对新车利润贡献率(新车毛利Ⅰ对新车利润贡献率);

        BigDecimal 新车毛利Ⅱ对新车利润贡献率 = 新车业务销售收入.compareTo(BigDecimal.ZERO) == 0 ? zero :
                新车业务销售收入.subtract(新车业务销售成本).add(新车业务返利).divide(新车业务销售收入, 4, BigDecimal.ROUND_HALF_EVEN);
        entity.set新车毛利Ⅱ对新车利润贡献率(新车毛利Ⅱ对新车利润贡献率);

        BigDecimal 精品加装平均单车 = 新车业务精品外销非原厂台次.compareTo(BigDecimal.ZERO) == 0 ? zero :
                新车业务精品外销非原厂收入.divide(新车业务精品外销非原厂台次, 4, BigDecimal.ROUND_HALF_EVEN);
        entity.set精品加装平均单车(精品加装平均单车);

        BigDecimal 消费信贷平均单车 = 新车业务车贷服务费及佣金台次.compareTo(BigDecimal.ZERO) == 0 ? zero :
                新车业务车贷佣金及手续费收入.divide(新车业务车贷服务费及佣金台次, 4, BigDecimal.ROUND_HALF_EVEN);
        entity.set消费信贷平均单车(消费信贷平均单车);

        BigDecimal 融资租赁平均单车 = 新车业务融资租赁服务费及佣金台次.compareTo(BigDecimal.ZERO) == 0 ? zero :
                新车业务租赁佣金及手续费收入.divide(新车业务融资租赁服务费及佣金台次, 4, BigDecimal.ROUND_HALF_EVEN);
        entity.set融资租赁平均单车(融资租赁平均单车);

        BigDecimal 新车保险平均单车 = 新车业务新保台次.compareTo(BigDecimal.ZERO) == 0 ? zero :
                新车业务新保佣金收入.divide(新车业务新保台次, 4, BigDecimal.ROUND_HALF_EVEN);
        entity.set新车保险平均单车(新车保险平均单车);

        BigDecimal 上牌及其他平均单车 = 新车业务其他收入台次.compareTo(BigDecimal.ZERO) == 0 ? zero :
                新车业务其他收入.divide(新车业务其他收入台次, 4, BigDecimal.ROUND_HALF_EVEN);
        entity.set上牌及其他平均单车(上牌及其他平均单车);

        BigDecimal 精品加装渗透率 = 新车业务精品外销非原厂台次.compareTo(BigDecimal.ZERO) == 0 ? zero :
                新车业务精品外销非原厂台次.divide(主营业务台次, 4, BigDecimal.ROUND_HALF_EVEN);
        entity.set精品加装渗透率(精品加装渗透率);

        BigDecimal 消费信贷渗透率 = 主营业务台次.compareTo(BigDecimal.ZERO) == 0 ? zero :
                新车业务车贷服务费及佣金台次.divide(主营业务台次, 4, BigDecimal.ROUND_HALF_EVEN);
        entity.set消费信贷渗透率(消费信贷渗透率);

        BigDecimal 融资租赁渗透率 = 主营业务台次.compareTo(BigDecimal.ZERO) == 0 ? zero :
                新车业务融资租赁服务费及佣金台次.divide(主营业务台次, 4, BigDecimal.ROUND_HALF_EVEN);
        entity.set融资租赁渗透率(融资租赁渗透率);

        BigDecimal 新车保险渗透率 = 主营业务台次.compareTo(BigDecimal.ZERO) == 0 ? zero :
                新车业务新保台次.divide(主营业务台次, 4, BigDecimal.ROUND_HALF_EVEN);
        entity.set新车保险渗透率(新车保险渗透率);

        BigDecimal 上牌及其他渗透率 = 主营业务台次.compareTo(BigDecimal.ZERO) == 0 ? zero :
                新车业务其他收入台次.divide(主营业务台次, 4, BigDecimal.ROUND_HALF_EVEN);
        entity.set上牌及其他渗透率(上牌及其他渗透率);

        BigDecimal 新车业务人工成本费用贡献 = 新车业务综合营业收入.compareTo(BigDecimal.ZERO) == 0 ? zero :
                新车业务各业务单元间接人工成本.divide(新车业务综合营业收入, 4, BigDecimal.ROUND_HALF_EVEN);
        entity.set新车业务人工成本费用贡献(新车业务人工成本费用贡献);

        BigDecimal 新车业务市场费用贡献 = 新车业务综合营业收入.compareTo(BigDecimal.ZERO) == 0 ? zero :
                新车业务各业务单元广告及市场费用.divide(新车业务综合营业收入, 4, BigDecimal.ROUND_HALF_EVEN);
        entity.set新车业务市场费用贡献(新车业务市场费用贡献);

        BigDecimal 新车业务财务费用贡献 = 新车业务综合营业收入.compareTo(BigDecimal.ZERO) == 0 ? zero :
                新车业务各业务单元财务费用.divide(新车业务综合营业收入, 4, BigDecimal.ROUND_HALF_EVEN);
        entity.set新车业务财务费用贡献(新车业务财务费用贡献);

        BigDecimal 新车业务其他费用贡献 = 新车业务综合营业收入.compareTo(BigDecimal.ZERO) == 0 ? zero :
                新车业务抵减后促销政策费用.add(新车业务其他可归属到业务的费用).divide(新车业务综合营业收入, 4, BigDecimal.ROUND_HALF_EVEN);
        entity.set新车业务其他费用贡献(新车业务其他费用贡献);

        BigDecimal 新车利润贡献 = 三级毛利率.subtract(新车业务人工成本费用贡献).subtract(新车业务市场费用贡献).subtract(新车业务财务费用贡献).subtract(新车业务其他费用贡献);
        entity.set新车利润贡献(新车利润贡献);

        BigDecimal 人工成本平均单车费用 = 新车销售台次.compareTo(BigDecimal.ZERO) == 0 ? zero :
                新车业务各业务单元间接人工成本.divide(新车销售台次, 4, BigDecimal.ROUND_HALF_EVEN);
        entity.set人工成本平均单车费用(人工成本平均单车费用);

        BigDecimal 广告平均单车费用 = 新车销售台次.compareTo(BigDecimal.ZERO) == 0 ? zero :
                新车业务各业务单元广告及市场费用.divide(新车销售台次, 4, BigDecimal.ROUND_HALF_EVEN);
        entity.set广告平均单车费用(广告平均单车费用);

        BigDecimal 财务平均单车费用 = 新车销售台次.compareTo(BigDecimal.ZERO) == 0 ? zero :
                新车业务各业务单元财务费用.divide(新车销售台次, 4, BigDecimal.ROUND_HALF_EVEN);
        entity.set财务平均单车费用(财务平均单车费用);

        BigDecimal 其他平均单车费用 = 新车销售台次.compareTo(BigDecimal.ZERO) == 0 ? zero :
                新车业务抵减后促销政策费用.add(新车业务其他可归属到业务的费用).divide(新车销售台次, 4, BigDecimal.ROUND_HALF_EVEN);
        entity.set其他平均单车费用(其他平均单车费用);

        BigDecimal 费用合计平均单店费用 = 人工成本平均单车费用.add(广告平均单车费用).add(财务平均单车费用).add(其他平均单车费用);
        entity.set费用合计平均单店费用(费用合计平均单店费用);

        BigDecimal 平均单车新车毛利Ⅰ = 新车销售台次.compareTo(BigDecimal.ZERO) == 0 ? zero :
                新车业务销售收入.subtract(新车业务销售成本).divide(新车销售台次, 4, BigDecimal.ROUND_HALF_EVEN);
        entity.set平均单车新车毛利Ⅰ(平均单车新车毛利Ⅰ);

        BigDecimal 平均单车金融衍生 = 新车销售台次.compareTo(BigDecimal.ZERO) == 0 ? zero :
                新车业务金融收入.divide(新车销售台次, 4, BigDecimal.ROUND_HALF_EVEN);
        entity.set平均单车金融衍生(平均单车金融衍生);

        BigDecimal 平均单车保险衍生 = 新车销售台次.compareTo(BigDecimal.ZERO) == 0 ? zero :
                新车业务保险收入.divide(新车销售台次, 4, BigDecimal.ROUND_HALF_EVEN);
        entity.set平均单车保险衍生(平均单车保险衍生);

        BigDecimal 平均单车其他衍生 = 新车销售台次.compareTo(BigDecimal.ZERO) == 0 ? zero :
                新车业务其他衍生收入.subtract(新车业务其他衍生成本).divide(新车销售台次, 4, BigDecimal.ROUND_HALF_EVEN);
        entity.set平均单车其他衍生(平均单车其他衍生);

        BigDecimal 平均单车精品备件衍生 = 新车销售台次.compareTo(BigDecimal.ZERO) == 0 ?
                zero.subtract(平均单车金融衍生).subtract(平均单车保险衍生).subtract(平均单车其他衍生) :
                新车业务衍生收入.subtract(新车业务衍生成本).divide(新车销售台次, 4, BigDecimal.ROUND_HALF_EVEN)
                        .subtract(平均单车金融衍生).subtract(平均单车保险衍生).subtract(平均单车其他衍生);
        entity.set平均单车精品备件衍生(平均单车精品备件衍生);


        //特殊处理年累计的指标
        if ("全国全年累计".equals(searchEnum.getSearchType()) || "大区全年累计".equals(searchEnum.getSearchType()) ||
                "经销商全年累计".equals(searchEnum.getSearchType())) {
            //全国全年累计-->全国 大区全年累计-->大区 经销商全年累计-->经销商
            SearchEnum searchEnumSpec = SearchEnum.valueOf(searchEnum.getSearchType().substring(0, searchEnum.getSearchType().length() - 4));
            List<DealerForm> dealerCount = baseMap.get("dealerCount");
            BigDecimal 平均单店新车毛利Ⅰ = zero;
            BigDecimal 平均单店新车返利 = zero;
            BigDecimal 平均单店新车毛利Ⅱ = zero;
            BigDecimal 平均单店金融衍生 = zero;
            BigDecimal 平均单店保险衍生 = zero;
            BigDecimal 平均单店其他衍生 = zero;
            BigDecimal 平均单店精品备件衍生 = zero;
            BigDecimal 平均单店新车毛利Ⅲ = zero;
            BigDecimal 平均单店人工成本不含工时 = zero;
            BigDecimal 平均单店市场费用 = zero;
            BigDecimal 平均单店财务费用 = zero;
            BigDecimal 平均单店其他业务费用 = zero;
            BigDecimal 平均单店新车利润 = zero;
            for (DealerForm form : dealerCount) {
                BigDecimal 当前季度经销商数量 = zero;
                String currentQuarter = form.getQuarterId();//当前季度
                String currentDealer = dealerForm.getJxsDealerId();//当前经销商ID

                //获取经销商数量
                if ("全国".equals(searchEnumSpec.getSearchType())) {
                    当前季度经销商数量 = new BigDecimal(form.getDealerCount());

                } else if ("大区".equals(searchEnumSpec.getSearchType())) {
                    当前季度经销商数量 = new BigDecimal(baseMap.get("regionDealerCount").stream()
                            .filter(x -> x.getQuarterId().equals(currentQuarter) && x.getRegionName().equals(regionEnum.getRegionName()))
                            .collect(Collectors.toList()).get(0).getDealerCount());

                } else if ("经销商".equals(searchEnumSpec.getSearchType())) {
                    当前季度经销商数量 = new BigDecimal("1");

                }

                平均单店新车毛利Ⅰ = 平均单店新车毛利Ⅰ.add(
                        getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.新车业务销售收入)
                                .subtract(getBaseIndex(yearId, form.getQuarterId(), regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.新车业务销售成本))
                                .divide(当前季度经销商数量, 4, BigDecimal.ROUND_HALF_EVEN));
                平均单店新车返利 = 平均单店新车返利.add(
                        getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.新车业务返利)
                                .divide(当前季度经销商数量, 4, BigDecimal.ROUND_HALF_EVEN));
                平均单店新车毛利Ⅱ = 平均单店新车毛利Ⅱ.add(
                        getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.新车业务销售收入)
                                .subtract(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.新车业务销售成本))
                                .add(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.新车业务返利))
                                .divide(当前季度经销商数量, 4, BigDecimal.ROUND_HALF_EVEN));
                平均单店金融衍生 = 平均单店金融衍生.add(
                        getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.新车业务金融收入)
                                .divide(当前季度经销商数量, 4, BigDecimal.ROUND_HALF_EVEN));
                平均单店保险衍生 = 平均单店保险衍生.add(
                        getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.新车业务保险收入)
                                .divide(当前季度经销商数量, 4, BigDecimal.ROUND_HALF_EVEN));
                平均单店其他衍生 = 平均单店其他衍生.add(
                        getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.新车业务其他衍生收入)
                                .subtract(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.新车业务其他衍生成本))
                                .divide(当前季度经销商数量, 4, BigDecimal.ROUND_HALF_EVEN));
                平均单店新车毛利Ⅲ = 平均单店新车毛利Ⅲ.add(
                        getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.新车业务综合营业收入)
                                .subtract(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.新车综合营业成本))
                                .add(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.新车业务返利))
                                .divide(当前季度经销商数量, 4, BigDecimal.ROUND_HALF_EVEN));
                平均单店人工成本不含工时 = 平均单店人工成本不含工时.add(
                        getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.新车业务各业务单元间接人工成本)
                                .divide(当前季度经销商数量, 4, BigDecimal.ROUND_HALF_EVEN));
                平均单店市场费用 = 平均单店市场费用.add(
                        getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.新车业务各业务单元广告及市场费用)
                                .divide(当前季度经销商数量, 4, BigDecimal.ROUND_HALF_EVEN));
                平均单店财务费用 = 平均单店财务费用.add(
                        getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.新车业务各业务单元财务费用)
                                .divide(当前季度经销商数量, 4, BigDecimal.ROUND_HALF_EVEN));
                平均单店其他业务费用 = 平均单店其他业务费用.add(
                        getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.新车业务抵减后促销政策费用)
                                .add(getBaseIndex(yearId, form.getQuarterId(), regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.新车业务其他可归属到业务的费用))
                                .divide(当前季度经销商数量, 4, BigDecimal.ROUND_HALF_EVEN));
                平均单店精品备件衍生 = 平均单店精品备件衍生.add(
                        getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.新车业务衍生收入)
                                .subtract(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.新车业务衍生成本))
                                .divide(当前季度经销商数量, 4, BigDecimal.ROUND_HALF_EVEN)
                                .subtract(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.新车业务金融收入)
                                        .divide(当前季度经销商数量, 4, BigDecimal.ROUND_HALF_EVEN))
                                .subtract(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.新车业务保险收入)
                                        .divide(当前季度经销商数量, 4, BigDecimal.ROUND_HALF_EVEN))
                                .subtract(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.新车业务其他衍生收入)
                                        .subtract(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.新车业务其他衍生成本))
                                        .divide(当前季度经销商数量, 4, BigDecimal.ROUND_HALF_EVEN)));
                平均单店新车利润 = 平均单店新车利润.add(
                        getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.新车业务综合营业收入)
                                .subtract(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.新车综合营业成本))
                                .add(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.新车业务返利))
                                .divide(当前季度经销商数量, 4, BigDecimal.ROUND_HALF_EVEN)
                                .subtract(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.新车业务各业务单元间接人工成本)
                                        .divide(当前季度经销商数量, 4, BigDecimal.ROUND_HALF_EVEN))
                                .subtract(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.新车业务各业务单元广告及市场费用)
                                        .divide(当前季度经销商数量, 4, BigDecimal.ROUND_HALF_EVEN))
                                .subtract(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.新车业务各业务单元财务费用)
                                        .divide(当前季度经销商数量, 4, BigDecimal.ROUND_HALF_EVEN))
                                .subtract(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.新车业务抵减后促销政策费用)
                                        .add(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.新车业务其他可归属到业务的费用))
                                        .divide(当前季度经销商数量, 4, BigDecimal.ROUND_HALF_EVEN)));
            }
            entity.set平均单店新车毛利Ⅰ(平均单店新车毛利Ⅰ);
            entity.set平均单店新车返利(平均单店新车返利);
            entity.set平均单店新车毛利Ⅱ(平均单店新车毛利Ⅱ);
            entity.set平均单店金融衍生(平均单店金融衍生);
            entity.set平均单店保险衍生(平均单店保险衍生);
            entity.set平均单店其他衍生(平均单店其他衍生);
            entity.set平均单店精品备件衍生(平均单店精品备件衍生);
            entity.set平均单店新车毛利Ⅲ(平均单店新车毛利Ⅲ);
            entity.set平均单店人工成本不含工时(平均单店人工成本不含工时);
            entity.set平均单店财务费用(平均单店财务费用);
            entity.set平均单店市场费用(平均单店市场费用);
            entity.set平均单店其他业务费用(平均单店其他业务费用);
            entity.set平均单店新车利润(平均单店新车利润);
        } else {
            //获取经销商数量
            BigDecimal 本季度经销商数量 = zero;

            if ("全国".equals(searchEnum.getSearchType())) {
                本季度经销商数量 = new BigDecimal(baseMap.get("dealerCount").stream().filter(
                        x -> x.getQuarterId().equals(quarterId))
                        .collect(Collectors.toList()).get(0).getDealerCount());

            } else if ("大区".equals(searchEnum.getSearchType())) {
                本季度经销商数量 = new BigDecimal(baseMap.get("regionDealerCount").stream().filter(
                        x -> x.getQuarterId().equals(quarterId) && x.getRegionName().equals(regionEnum.getRegionName()))
                        .collect(Collectors.toList()).get(0).getDealerCount());

            } else if ("经销商".equals(searchEnum.getSearchType())) {
                本季度经销商数量 = new BigDecimal("1");

            }


            BigDecimal 平均单店新车毛利Ⅰ = 本季度经销商数量.compareTo(BigDecimal.ZERO) == 0 ? zero :
                    新车业务销售收入.subtract(新车业务销售成本).divide(本季度经销商数量, 4, BigDecimal.ROUND_HALF_EVEN);
            entity.set平均单店新车毛利Ⅰ(平均单店新车毛利Ⅰ);

            BigDecimal 平均单店新车返利 = 本季度经销商数量.compareTo(BigDecimal.ZERO) == 0 ? zero :
                    新车业务返利.divide(本季度经销商数量, 4, BigDecimal.ROUND_HALF_EVEN);
            entity.set平均单店新车返利(平均单店新车返利);

            BigDecimal 平均单店新车毛利Ⅱ = 本季度经销商数量.compareTo(BigDecimal.ZERO) == 0 ? zero :
                    新车业务销售收入.subtract(新车业务销售成本).add(新车业务返利).divide(本季度经销商数量, 4, BigDecimal.ROUND_HALF_EVEN);
            entity.set平均单店新车毛利Ⅱ(平均单店新车毛利Ⅱ);

            BigDecimal 平均单店金融衍生 = 本季度经销商数量.compareTo(BigDecimal.ZERO) == 0 ? zero :
                    新车业务金融收入.divide(本季度经销商数量, 4, BigDecimal.ROUND_HALF_EVEN);
            entity.set平均单店金融衍生(平均单店金融衍生);

            BigDecimal 平均单店保险衍生 = 本季度经销商数量.compareTo(BigDecimal.ZERO) == 0 ? zero :
                    新车业务保险收入.divide(本季度经销商数量, 4, BigDecimal.ROUND_HALF_EVEN);
            entity.set平均单店保险衍生(平均单店保险衍生);

            BigDecimal 平均单店其他衍生 = 本季度经销商数量.compareTo(BigDecimal.ZERO) == 0 ? zero :
                    新车业务其他衍生收入.subtract(新车业务其他衍生成本).divide(本季度经销商数量, 4, BigDecimal.ROUND_HALF_EVEN);
            entity.set平均单店其他衍生(平均单店其他衍生);

            BigDecimal 平均单店精品备件衍生 = 本季度经销商数量.compareTo(BigDecimal.ZERO) == 0 ?
                    zero.subtract(平均单店其他衍生).subtract(平均单店保险衍生).subtract(平均单店其他衍生) :
                    新车业务衍生收入.subtract(新车业务衍生成本).divide(本季度经销商数量, 4, BigDecimal.ROUND_HALF_EVEN)
                            .subtract(平均单店其他衍生).subtract(平均单店保险衍生).subtract(平均单店其他衍生);
            entity.set平均单店精品备件衍生(平均单店精品备件衍生);

            BigDecimal 平均单店新车毛利Ⅲ = 本季度经销商数量.compareTo(BigDecimal.ZERO) == 0 ? zero :
                    新车业务综合营业收入.subtract(新车综合营业成本).add(新车业务返利).divide(本季度经销商数量, 4, BigDecimal.ROUND_HALF_EVEN);
            entity.set平均单店新车毛利Ⅲ(平均单店新车毛利Ⅲ);

            BigDecimal 平均单店人工成本不含工时 = 本季度经销商数量.compareTo(BigDecimal.ZERO) == 0 ? zero :
                    新车业务各业务单元间接人工成本.divide(本季度经销商数量, 4, BigDecimal.ROUND_HALF_EVEN);
            entity.set平均单店人工成本不含工时(平均单店人工成本不含工时);

            BigDecimal 平均单店市场费用 = 本季度经销商数量.compareTo(BigDecimal.ZERO) == 0 ? zero :
                    新车业务各业务单元广告及市场费用.divide(本季度经销商数量, 4, BigDecimal.ROUND_HALF_EVEN);
            entity.set平均单店市场费用(平均单店市场费用);

            BigDecimal 平均单店财务费用 = 本季度经销商数量.compareTo(BigDecimal.ZERO) == 0 ? zero :
                    新车业务各业务单元财务费用.divide(本季度经销商数量, 4, BigDecimal.ROUND_HALF_EVEN);
            entity.set平均单店财务费用(平均单店财务费用);

            BigDecimal 平均单店其他业务费用 = 本季度经销商数量.compareTo(BigDecimal.ZERO) == 0 ? zero :
                    新车业务抵减后促销政策费用.add(新车业务其他可归属到业务的费用).divide(本季度经销商数量, 4, BigDecimal.ROUND_HALF_EVEN);
            entity.set平均单店其他业务费用(平均单店其他业务费用);

            BigDecimal 平均单店新车利润 = 平均单店新车毛利Ⅲ.subtract(平均单店人工成本不含工时).subtract(平均单店市场费用).subtract(平均单店财务费用).subtract(平均单店其他业务费用);
            entity.set平均单店新车利润(平均单店新车利润);
        }

        return entity;

    }

    @Override
    public UsedIndex getUsedCollectIndex(String yearId, String quarterId, DealerForm dealerForm, Map<String, List<DealerForm>> baseMap,
                                         RegionEnum regionEnum, SearchEnum searchEnum) {
        UsedIndex entity = new UsedIndex();
        BigDecimal zero = new BigDecimal("0");
        String dealerId = dealerForm.getJxsDealerId();
        String regionName = regionEnum.getRegionName();

        if ("".equals(regionName)) {
            if (dealerId != null) {
                entity.set经销商ID(dealerId);
                entity.set统计范围分类(0);//经销商
            } else {
                entity.set统计范围分类(4);//全国
            }
        } else {
            entity.set区域ID(regionEnum.getRegionId());
            entity.set统计范围分类(3);//大区
        }

        //获取基础指标
        BigDecimal 二手车销售收入 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.二手车销售收入);
        entity.set二手车销售收入(二手车销售收入);
        BigDecimal 二手车销售成本 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.二手车销售成本);
        BigDecimal 二手车返利 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.二手车返利);
        BigDecimal 二手车销售台次 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.二手车销售台次);
        entity.set二手车销售台次(二手车销售台次);
        BigDecimal 二手车业务综合营业收入 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.二手车业务综合营业收入);
        BigDecimal 二手车业务综合营业成本 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.二手车业务综合营业成本);
        BigDecimal 综合营业收入 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.综合营业收入);


        BigDecimal 二手车二级毛利率 = 二手车销售收入.compareTo(BigDecimal.ZERO) == 0 ? zero :
                二手车销售收入.subtract(二手车销售成本).add(二手车返利)
                        .divide(二手车销售收入, 4, BigDecimal.ROUND_HALF_EVEN);
        entity.set二手车二级毛利率(二手车二级毛利率);

        BigDecimal 平均单车收入 = 二手车销售台次.compareTo(BigDecimal.ZERO) == 0 ? zero :
                二手车销售收入.divide(二手车销售台次, 4, BigDecimal.ROUND_HALF_EVEN);
        entity.set平均单车收入(平均单车收入);

        BigDecimal 二手车业务毛利贡献率 = 综合营业收入.compareTo(BigDecimal.ZERO) == 0 ? zero :
                二手车业务综合营业收入.subtract(二手车业务综合营业成本).add(二手车返利)
                        .divide(综合营业收入, 4, BigDecimal.ROUND_HALF_EVEN);
        entity.set二手车业务毛利贡献率(二手车业务毛利贡献率);

        if ("全国全年累计".equals(searchEnum.getSearchType()) || "大区全年累计".equals(searchEnum.getSearchType()) ||
                "经销商全年累计".equals(searchEnum.getSearchType())) {

            SearchEnum searchEnumSpec = SearchEnum.valueOf(searchEnum.getSearchType().substring(0, searchEnum.getSearchType().length() - 4));
            List<DealerForm> dealerCount = baseMap.get("dealerCount");

            BigDecimal 二手车平均单店收入 = zero;
            BigDecimal 二手车平均单店 = zero;

            for (DealerForm form : dealerCount) {
                //获取经销商数量
                BigDecimal 当前季度经销商数量 = zero;
                String currentQuarter = form.getQuarterId();
                String currentDealer = dealerForm.getJxsDealerId();
                if ("全国".equals(searchEnumSpec.getSearchType())) {
                    当前季度经销商数量 = new BigDecimal(form.getDealerCount());

                } else if ("大区".equals(searchEnumSpec.getSearchType())) {
                    当前季度经销商数量 = new BigDecimal(
                            baseMap.get("regionDealerCount").stream().filter(
                                    x -> x.getQuarterId().equals(currentQuarter) && x.getRegionName().equals(regionEnum.getRegionName()))
                                    .collect(Collectors.toList()).get(0).getDealerCount());

                } else if ("经销商".equals(searchEnumSpec.getSearchType())) {
                    当前季度经销商数量 = new BigDecimal("1");

                }

                二手车平均单店收入 = 二手车平均单店收入.add(
                        getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.二手车销售收入)
                                .divide(当前季度经销商数量, 4, BigDecimal.ROUND_HALF_EVEN));
                二手车平均单店 = 二手车平均单店.add(
                        getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.二手车业务综合营业收入)
                                .subtract(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.二手车业务综合营业成本))
                                .add(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.二手车返利))
                                .divide(当前季度经销商数量, 4, BigDecimal.ROUND_HALF_EVEN));
            }
            entity.set二手车平均单店收入(二手车平均单店收入);
            entity.set二手车平均单店(二手车平均单店);

        } else {
            //获取经销商数量
            BigDecimal 本季度经销商数量 = zero;

            if ("全国".equals(searchEnum.getSearchType())) {
                本季度经销商数量 = new BigDecimal(baseMap.get("dealerCount").stream().filter(
                        x -> x.getQuarterId().equals(quarterId))
                        .collect(Collectors.toList()).get(0).getDealerCount());

            } else if ("大区".equals(searchEnum.getSearchType())) {
                本季度经销商数量 = new BigDecimal(baseMap.get("regionDealerCount").stream().filter(
                        x -> x.getQuarterId().equals(quarterId) && x.getRegionName().equals(regionEnum.getRegionName()))
                        .collect(Collectors.toList()).get(0).getDealerCount());

            } else if ("经销商".equals(searchEnum.getSearchType())) {
                本季度经销商数量 = new BigDecimal("1");

            }

            BigDecimal 二手车平均单店收入 = 本季度经销商数量.compareTo(BigDecimal.ZERO) == 0 ? zero :
                    二手车销售收入.divide(本季度经销商数量, 4, BigDecimal.ROUND_HALF_EVEN);
            entity.set二手车平均单店收入(二手车平均单店收入);

            BigDecimal 二手车平均单店 = 本季度经销商数量.compareTo(BigDecimal.ZERO) == 0 ? zero :
                    二手车业务综合营业收入.subtract(二手车业务综合营业成本).add(二手车返利).divide(本季度经销商数量, 4, BigDecimal.ROUND_HALF_EVEN);
            entity.set二手车平均单店(二手车平均单店);

        }

        return entity;
    }

    @Override
    public GlobalIndex getGlobalCollectIndex(String yearId, String quarterId, DealerForm dealerForm, Map<String, List<DealerForm>> baseMap,
                                             RegionEnum regionEnum, SearchEnum searchEnum) {

        GlobalIndex entity = new GlobalIndex();
        BigDecimal zero = new BigDecimal("0");
        String dealerId = dealerForm.getJxsDealerId();
        String regionName = regionEnum.getRegionName();

        if ("".equals(regionName)) {
            if (dealerId != null) {
                entity.set经销商ID(dealerId);
                entity.set统计范围分类(0);//经销商
            } else {
                entity.set统计范围分类(4);//全国
            }
        } else {
            entity.set区域ID(regionEnum.getRegionId());
            entity.set统计范围分类(3);//大区
        }

        BigDecimal 其他业务综合营业收入 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.其他业务综合营业收入);
        BigDecimal 其他业务综合营业成本 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.其他业务综合营业成本);
        BigDecimal 其他业务返利 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.其他业务返利);
        BigDecimal 综合营业成本 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.综合营业成本);
        BigDecimal 返利 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.返利);
        BigDecimal 各业务单元间接人工成本 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.各业务单元间接人工成本);
        BigDecimal 各业务单元财务费用 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.各业务单元财务费用);
        BigDecimal 各业务单元广告及市场费用 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.各业务单元广告及市场费用);
        BigDecimal 抵减后促销政策费用 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.抵减后促销政策费用);
        BigDecimal 其他可归属到业务的费用 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.其他可归属到业务的费用);
        BigDecimal 后勤管理部门的人工成本 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.后勤管理部门的人工成本);
        BigDecimal 后勤管理部门的财务费用 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.后勤管理部门的财务费用);
        BigDecimal 后勤管理部门的广告费用 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.后勤管理部门的广告费用);
        BigDecimal 折旧摊销费用 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.折旧摊销费用);
        BigDecimal 租赁费 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.租赁费);
        BigDecimal 培训差旅费 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.培训差旅费);
        BigDecimal 水电煤气费 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.水电煤气费);
        BigDecimal 业务招待费 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.业务招待费);
        BigDecimal 办公费 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.办公费);
        BigDecimal 税金及附加 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.税金及附加);
        BigDecimal 低值易耗品及物料消耗费 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.低值易耗品及物料消耗费);
        BigDecimal 展厅车间设备维护费 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.展厅车间设备维护费);
        BigDecimal 保险费 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.保险费);
        BigDecimal 审计咨询费 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.审计咨询费);
        BigDecimal 食堂费 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.食堂费);
        BigDecimal 集团管理费 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.集团管理费);
        BigDecimal 开办费待摊费用摊销 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.开办费待摊费用摊销);
        BigDecimal 其他经营管理费用 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.其他经营管理费用);
        BigDecimal 资产减值损失 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.资产减值损失);
        BigDecimal 公允价值变动收益 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.公允价值变动收益);
        BigDecimal 投资收益 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.投资收益);
        BigDecimal 资产处置收益 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.资产处置收益);
        BigDecimal 其他收益 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.其他收益);
        BigDecimal 营业外收入 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.营业外收入);
        BigDecimal 营业外支出 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.营业外支出);
        BigDecimal 维修业务工时成本 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.维修业务工时成本);
        BigDecimal 综合营业收入 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.综合营业收入);
        entity.set综合营业收入(综合营业收入);
        BigDecimal 总体销售收入 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.总体销售收入);
        BigDecimal 总体销售成本 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.总体销售成本);

        BigDecimal 一级毛利率 = 总体销售收入.compareTo(BigDecimal.ZERO) == 0 ? zero :
                总体销售收入.subtract(总体销售成本).divide(总体销售收入, 4, BigDecimal.ROUND_HALF_EVEN);
        entity.set一级毛利率(一级毛利率);

        BigDecimal 一级毛利 = 总体销售收入.subtract(总体销售成本);
        entity.set一级毛利(一级毛利);

        BigDecimal 二级毛利 = 总体销售收入.subtract(总体销售成本).add(返利);
        entity.set二级毛利(二级毛利);

        BigDecimal 二级毛利率 = 总体销售收入.compareTo(BigDecimal.ZERO) == 0 ? zero :
                总体销售收入.subtract(总体销售成本).add(返利).divide(总体销售收入, 4, BigDecimal.ROUND_HALF_EVEN);
        entity.set二级毛利率(二级毛利率);

        BigDecimal 三级毛利 = 综合营业收入.subtract(综合营业成本).add(返利);
        entity.set三级毛利(三级毛利);

        BigDecimal 三级毛利率 = 综合营业收入.compareTo(BigDecimal.ZERO) == 0 ? zero :
                综合营业收入.subtract(综合营业成本).add(返利).divide(综合营业收入, 4, BigDecimal.ROUND_HALF_EVEN);
        entity.set三级毛利率(三级毛利率);

        BigDecimal 各项经营费用总计 = 各业务单元间接人工成本.add(各业务单元财务费用).add(各业务单元广告及市场费用).add(抵减后促销政策费用).add(其他可归属到业务的费用)
                .add(后勤管理部门的人工成本).add(后勤管理部门的财务费用).add(后勤管理部门的广告费用).add(折旧摊销费用).add(租赁费).add(培训差旅费).add(水电煤气费)
                .add(业务招待费).add(办公费).add(税金及附加).add(低值易耗品及物料消耗费).add(展厅车间设备维护费).add(保险费).add(审计咨询费).add(食堂费).add(集团管理费)
                .add(开办费待摊费用摊销).add(其他经营管理费用);
        entity.set各项经营费用总计(各项经营费用总计);

        BigDecimal 其他经营性损益 = 资产减值损失.subtract(公允价值变动收益).subtract(投资收益).subtract(资产处置收益).subtract(其他收益);
        entity.set其他经营性损益(其他经营性损益);

        BigDecimal 其他业务毛利贡献率 = 综合营业收入.compareTo(BigDecimal.ZERO) == 0 ? zero :
                其他业务综合营业收入.subtract(其他业务综合营业成本).add(其他业务返利).divide(综合营业收入, 4, BigDecimal.ROUND_HALF_EVEN);
        entity.set其他业务毛利贡献率(其他业务毛利贡献率);

        BigDecimal 税前净利润率 = 综合营业收入.compareTo(BigDecimal.ZERO) == 0 ? zero :
                综合营业收入.subtract(综合营业成本).add(返利).subtract(各项经营费用总计).add(营业外收入).subtract(营业外支出).subtract(其他经营性损益)
                        .divide(综合营业收入, 4, BigDecimal.ROUND_HALF_EVEN);

        entity.set税前净利润率(税前净利润率);

        BigDecimal EBT本年累计税前净利润率 = 税前净利润率;
        entity.setEBT本年累计税前净利润率(EBT本年累计税前净利润率);

        BigDecimal 本季度经销商数量 = zero;
        if ("全国".equals(searchEnum.getSearchType())) {
            本季度经销商数量 = new BigDecimal(baseMap.get("dealerCount").stream().filter(
                    x -> x.getQuarterId().equals(quarterId))
                    .collect(Collectors.toList()).get(0).getDealerCount());

        } else if ("大区".equals(searchEnum.getSearchType())) {
            本季度经销商数量 = new BigDecimal(baseMap.get("regionDealerCount").stream().filter(
                    x -> x.getQuarterId().equals(quarterId) && x.getRegionName().equals(regionEnum.getRegionName()))
                    .collect(Collectors.toList()).get(0).getDealerCount());

        } else if ("经销商".equals(searchEnum.getSearchType())) {
            本季度经销商数量 = new BigDecimal("1");

        }

        BigDecimal 税前净利润平均单店 = 本季度经销商数量.compareTo(BigDecimal.ZERO) == 0 ? zero :
                综合营业收入.subtract(综合营业成本).add(返利).add(营业外收入).subtract(营业外支出).subtract(各项经营费用总计).subtract(其他经营性损益)
                        .divide(本季度经销商数量, 4, BigDecimal.ROUND_HALF_EVEN);
        entity.set税前净利润平均单店(税前净利润平均单店);

        BigDecimal 平均单店营业收入 = 本季度经销商数量.compareTo(BigDecimal.ZERO) == 0 ? zero :
                综合营业收入.divide(本季度经销商数量, 4, BigDecimal.ROUND_HALF_EVEN);
        entity.set平均单店营业收入(平均单店营业收入);

        BigDecimal 综合毛利率 = 综合营业收入.compareTo(BigDecimal.ZERO) == 0 ? zero :
                综合营业收入.subtract(综合营业成本).add(返利).divide(综合营业收入, 4, BigDecimal.ROUND_HALF_EVEN);
        entity.set综合毛利率(综合毛利率);

        BigDecimal 费用率 = 综合营业收入.compareTo(BigDecimal.ZERO) == 0 ? zero :
                各项经营费用总计.divide(综合营业收入, 4, BigDecimal.ROUND_HALF_EVEN);
        entity.set费用率(费用率);

        //只计算累计
        if ("全国全年累计".equals(searchEnum.getSearchType()) || "大区全年累计".equals(searchEnum.getSearchType()) ||
                "经销商全年累计".equals(searchEnum.getSearchType())) {

            BigDecimal 折旧费用率 = 综合营业收入.compareTo(BigDecimal.ZERO) == 0 ? zero :
                    折旧摊销费用.divide(综合营业收入, 4, BigDecimal.ROUND_HALF_EVEN);
            entity.set折旧费用率(折旧费用率);

            BigDecimal 广告费用率 = 综合营业收入.compareTo(BigDecimal.ZERO) == 0 ? zero :
                    各业务单元广告及市场费用.add(后勤管理部门的广告费用).divide(综合营业收入, 4, BigDecimal.ROUND_HALF_EVEN);
            entity.set广告费用率(广告费用率);

            BigDecimal 财务费用率 = 综合营业收入.compareTo(BigDecimal.ZERO) == 0 ? zero :
                    后勤管理部门的财务费用.add(各业务单元财务费用).divide(综合营业收入, 4, BigDecimal.ROUND_HALF_EVEN);
            entity.set财务费用率(财务费用率);

            BigDecimal 费用总计费用率 = 综合营业收入.compareTo(BigDecimal.ZERO) == 0 ? zero :
                    各项经营费用总计.divide(综合营业收入, 4, BigDecimal.ROUND_HALF_EVEN);
            entity.set费用总计费用率(费用总计费用率);

            BigDecimal 其他费用总计 = 抵减后促销政策费用.add(其他可归属到业务的费用).add(租赁费).add(培训差旅费).add(水电煤气费).add(办公费).add(税金及附加)
                    .add(低值易耗品及物料消耗费).add(展厅车间设备维护费).add(保险费).add(审计咨询费).add(食堂费).add(集团管理费).add(开办费待摊费用摊销)
                    .add(其他经营管理费用).add(业务招待费);
            entity.set其他费用总计(其他费用总计);

            BigDecimal 其他费用率 = 综合营业收入.compareTo(BigDecimal.ZERO) == 0 ? zero :
                    其他费用总计.divide(综合营业收入, 4, BigDecimal.ROUND_HALF_EVEN);
            entity.set其他费用率(其他费用率);

            BigDecimal 人工成本费用率 = 综合营业收入.compareTo(BigDecimal.ZERO) == 0 ? zero :
                    各业务单元间接人工成本.add(后勤管理部门的人工成本).divide(综合营业收入, 4, BigDecimal.ROUND_HALF_EVEN);
            entity.set人工成本费用率(人工成本费用率);

            BigDecimal 人工成本费用率含人工 = 综合营业收入.compareTo(BigDecimal.ZERO) == 0 ? zero :
                    维修业务工时成本.add(各业务单元间接人工成本).add(后勤管理部门的人工成本).divide(综合营业收入, 4, BigDecimal.ROUND_HALF_EVEN);
            entity.set人工成本费用率含人工(人工成本费用率含人工);


        }

        //只计算累计(特殊处理)
        if ("全国全年累计".equals(searchEnum.getSearchType()) || "大区全年累计".equals(searchEnum.getSearchType()) ||
                "经销商全年累计".equals(searchEnum.getSearchType())) {

            SearchEnum searchEnumSpec = SearchEnum.valueOf(searchEnum.getSearchType().substring(0, searchEnum.getSearchType().length() - 4));
            List<DealerForm> dealerCount = baseMap.get("dealerCount");

            BigDecimal 折旧平均单店费用 = zero;
            BigDecimal 广告平均单点费用 = zero;
            BigDecimal 财务平均单店费用 = zero;
            BigDecimal 费用总计平均单店费用 = zero;
            BigDecimal 其他费用平均单店费用 = zero;
            BigDecimal 人工成本平均单店费用不含人工 = zero;
            BigDecimal 其他业务平均单店 = zero;
            税前净利润平均单店 = zero;
            BigDecimal 人工成本含人工单店费用 = zero;
            平均单店营业收入 = zero;

            for (DealerForm form : dealerCount) {
                //获取经销商数量
                BigDecimal 当前季度经销商数量 = zero;
                String currentQuarter = form.getQuarterId();
                String currentDealer = dealerForm.getJxsDealerId();
                if ("全国".equals(searchEnumSpec.getSearchType())) {
                    当前季度经销商数量 = new BigDecimal(form.getDealerCount());

                } else if ("大区".equals(searchEnumSpec.getSearchType())) {
                    当前季度经销商数量 = new BigDecimal(
                            baseMap.get("regionDealerCount").stream().filter(
                                    x -> x.getQuarterId().equals(currentQuarter) && x.getRegionName().equals(regionEnum.getRegionName()))
                                    .collect(Collectors.toList()).get(0).getDealerCount());

                } else if ("经销商".equals(searchEnumSpec.getSearchType())) {
                    当前季度经销商数量 = new BigDecimal("1");

                }
                平均单店营业收入 = 平均单店营业收入.add(
                        getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.综合营业收入)
                                .divide(当前季度经销商数量, 4, BigDecimal.ROUND_HALF_EVEN));

                人工成本含人工单店费用 = 人工成本含人工单店费用.add(
                        getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.各业务单元间接人工成本)
                                .add(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.后勤管理部门的人工成本))
                                .add(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.维修业务工时成本))
                                .divide(当前季度经销商数量, 4, BigDecimal.ROUND_HALF_EVEN));

                BigDecimal 各项经营费用总计当前季度 = getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.各业务单元间接人工成本)
                        .add(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.各业务单元财务费用))
                        .add(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.各业务单元广告及市场费用))
                        .add(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.抵减后促销政策费用))
                        .add(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.其他可归属到业务的费用))
                        .add(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.后勤管理部门的人工成本))
                        .add(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.后勤管理部门的财务费用))
                        .add(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.后勤管理部门的广告费用))
                        .add(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.折旧摊销费用))
                        .add(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.租赁费))
                        .add(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.培训差旅费))
                        .add(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.水电煤气费))
                        .add(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.业务招待费))
                        .add(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.办公费))
                        .add(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.税金及附加))
                        .add(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.低值易耗品及物料消耗费))
                        .add(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.展厅车间设备维护费))
                        .add(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.保险费))
                        .add(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.审计咨询费))
                        .add(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.食堂费))
                        .add(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.集团管理费))
                        .add(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.开办费待摊费用摊销))
                        .add(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.其他经营管理费用));

                折旧平均单店费用 = 折旧平均单店费用.add(
                        getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.折旧摊销费用)
                                .divide(当前季度经销商数量, 4, BigDecimal.ROUND_HALF_EVEN));

                广告平均单点费用 = 广告平均单点费用.add(
                        getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.各业务单元广告及市场费用)
                                .add(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.后勤管理部门的广告费用))
                                .divide(当前季度经销商数量, 4, BigDecimal.ROUND_HALF_EVEN));

                财务平均单店费用 = 财务平均单店费用.add(
                        getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.后勤管理部门的财务费用)
                                .add(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.各业务单元财务费用))
                                .divide(当前季度经销商数量, 4, BigDecimal.ROUND_HALF_EVEN)
                );

                费用总计平均单店费用 = 费用总计平均单店费用.add(各项经营费用总计当前季度.divide(当前季度经销商数量, 4, BigDecimal.ROUND_HALF_EVEN));

                其他费用平均单店费用 = 其他费用平均单店费用.add(
                        getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.抵减后促销政策费用)
                                .add(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.其他可归属到业务的费用))
                                .add(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.租赁费))
                                .add(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.培训差旅费))
                                .add(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.水电煤气费))
                                .add(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.办公费))
                                .add(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.税金及附加))
                                .add(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.低值易耗品及物料消耗费))
                                .add(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.展厅车间设备维护费))
                                .add(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.保险费))
                                .add(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.审计咨询费))
                                .add(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.食堂费))
                                .add(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.集团管理费))
                                .add(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.开办费待摊费用摊销))
                                .add(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.其他经营管理费用))
                                .add(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.业务招待费))
                                .add(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.展厅车间设备维护费))
                                .divide(当前季度经销商数量, 4, BigDecimal.ROUND_HALF_EVEN));

                人工成本平均单店费用不含人工 = 人工成本平均单店费用不含人工.add(
                        getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.各业务单元间接人工成本)
                                .add(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.后勤管理部门的人工成本))
                                .divide(当前季度经销商数量, 4, BigDecimal.ROUND_HALF_EVEN));

                其他业务平均单店 = 其他业务平均单店.add(
                        getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.其他业务综合营业收入)
                                .subtract(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.其他业务综合营业成本))
                                .add(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.其他业务返利))
                                .divide(当前季度经销商数量, 4, BigDecimal.ROUND_HALF_EVEN));

                BigDecimal 其他经营性损益当前季度 = getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.资产减值损失)
                        .subtract(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.公允价值变动收益))
                        .subtract(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.投资收益))
                        .subtract(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.资产处置收益))
                        .subtract(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.其他收益));


                税前净利润平均单店 = 税前净利润平均单店.add(
                        getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.综合营业收入)
                                .subtract(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.综合营业成本))
                                .add(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.返利))
                                .add(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.营业外收入))
                                .subtract(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.营业外支出))
                                .subtract(各项经营费用总计当前季度)
                                .subtract(其他经营性损益当前季度)
                                .divide(当前季度经销商数量, 4, BigDecimal.ROUND_HALF_EVEN));

            }

            entity.set折旧平均单店费用(折旧平均单店费用);
            entity.set广告平均单点费用(广告平均单点费用);
            entity.set财务平均单店费用(财务平均单店费用);
            entity.set费用总计平均单店费用(费用总计平均单店费用);
            entity.set其他费用平均单店费用(其他费用平均单店费用);
            entity.set人工成本平均单店费用不含人工(人工成本平均单店费用不含人工);
            entity.set其他业务平均单店(其他业务平均单店);
            entity.set税前净利润平均单店(税前净利润平均单店);
            entity.set人工成本含人工单店费用(人工成本含人工单店费用);
            entity.set平均单店营业收入(平均单店营业收入);

        }


        return entity;
    }

    @Override
    public AfterSaleIndex getAfterSaleCollectIndex(String yearId, String quarterId, DealerForm dealerForm, Map<String, List<DealerForm>> baseMap,
                                                   RegionEnum regionEnum, SearchEnum searchEnum) {

        AfterSaleIndex entity = new AfterSaleIndex();
        BigDecimal zero = new BigDecimal("0");
        String dealerId = dealerForm.getJxsDealerId();
        String regionName = regionEnum.getRegionName();

        if ("".equals(regionName)) {
            if (dealerId != null) {
                entity.set经销商ID(dealerId);
                entity.set统计范围分类(0);//经销商
            } else {
                entity.set统计范围分类(4);//全国
            }
        } else {
            entity.set区域ID(regionEnum.getRegionId());
            entity.set统计范围分类(3);//大区
        }

        BigDecimal 维修业务销售收入 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.维修业务销售收入);
        BigDecimal 售后主营业务台次 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.售后主营业务台次);
        BigDecimal 维修业务材料成本 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.维修业务材料成本);
        BigDecimal 维修业务返利 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.维修业务返利);
        BigDecimal 售后销售成本 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.售后销售成本);
        BigDecimal 售后衍生收入 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.售后衍生收入);
        BigDecimal 售后衍生成本 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.售后衍生成本);
        BigDecimal 售后综合营业收入 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.售后综合营业收入);
        BigDecimal 索赔销售收入 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.索赔销售收入);
        BigDecimal 索赔材料成本 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.索赔材料成本);
        BigDecimal 保养销售收入 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.保养销售收入);
        BigDecimal 保养材料成本 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.保养材料成本);
        BigDecimal 事故车销售收入 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.事故车销售收入);
        BigDecimal 事故车材料成本 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.事故车材料成本);
        BigDecimal 自费销售收入 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.自费销售收入);
        BigDecimal 自费材料成本 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.自费材料成本);
        BigDecimal 维修业务保险收入 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.维修业务保险收入);
        BigDecimal 索赔主营业务台次 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.索赔主营业务台次);
        BigDecimal 自费主营业务台次 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.自费主营业务台次);
        BigDecimal 事故车主营业务台次 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.事故车主营业务台次);
        BigDecimal 维修业务工时成本 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.维修业务工时成本);
        BigDecimal 维修业务各业务单元间接人工成本 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.维修业务各业务单元间接人工成本);
        BigDecimal 维修业务各业务单元广告及市场费用 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.维修业务各业务单元广告及市场费用);
        BigDecimal 维修业务各业务单元财务费用 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.维修业务各业务单元财务费用);
        BigDecimal 维修业务抵减后促销政策费用 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.维修业务抵减后促销政策费用);
        BigDecimal 维修业务其他可归属到业务的费用 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.维修业务其他可归属到业务的费用);
        BigDecimal 各业务单元间接人工成本 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.各业务单元间接人工成本);
        BigDecimal 各业务单元财务费用 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.各业务单元财务费用);
        BigDecimal 各业务单元广告及市场费用 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.各业务单元广告及市场费用);
        BigDecimal 抵减后促销政策费用 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.抵减后促销政策费用);
        BigDecimal 其他可归属到业务的费用 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.其他可归属到业务的费用);
        BigDecimal 后勤管理部门的人工成本 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.后勤管理部门的人工成本);
        BigDecimal 后勤管理部门的财务费用 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.后勤管理部门的财务费用);
        BigDecimal 后勤管理部门的广告费用 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.后勤管理部门的广告费用);
        BigDecimal 折旧摊销费用 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.折旧摊销费用);
        BigDecimal 租赁费 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.租赁费);
        BigDecimal 培训差旅费 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.培训差旅费);
        BigDecimal 水电煤气费 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.水电煤气费);
        BigDecimal 业务招待费 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.业务招待费);
        BigDecimal 办公费 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.办公费);
        BigDecimal 税金及附加 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.税金及附加);
        BigDecimal 低值易耗品及物料消耗费 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.低值易耗品及物料消耗费);
        BigDecimal 展厅车间设备维护费 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.展厅车间设备维护费);
        BigDecimal 保险费 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.保险费);
        BigDecimal 审计咨询费 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.审计咨询费);
        BigDecimal 食堂费 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.食堂费);
        BigDecimal 集团管理费 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.集团管理费);
        BigDecimal 开办费待摊费用摊销 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.开办费待摊费用摊销);
        BigDecimal 其他经营管理费用 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.其他经营管理费用);
        BigDecimal 综合营业收入 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.综合营业收入);
        BigDecimal 售后业务保险收入 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.售后业务保险收入);
        BigDecimal 保养主营业务台次 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.保养主营业务台次);

        BigDecimal 售后GPⅠ = 维修业务销售收入.compareTo(BigDecimal.ZERO) == 0 ? zero :
                维修业务销售收入.subtract(售后销售成本).divide(维修业务销售收入, 4, BigDecimal.ROUND_HALF_EVEN);
        entity.set售后GPⅠ(售后GPⅠ);

        BigDecimal 平均单车索赔售后产值 = 售后主营业务台次.compareTo(BigDecimal.ZERO) == 0 ? zero :
                索赔销售收入.divide(售后主营业务台次, 4, BigDecimal.ROUND_HALF_EVEN);
        entity.set平均单车索赔售后产值(平均单车索赔售后产值);

        BigDecimal 平均单车保养售后产值 = 售后主营业务台次.compareTo(BigDecimal.ZERO) == 0 ? zero :
                保养销售收入.divide(售后主营业务台次, 4, BigDecimal.ROUND_HALF_EVEN);
        entity.set平均单车保养售后产值(平均单车保养售后产值);

        BigDecimal 平均单车自费售后产值 = 售后主营业务台次.compareTo(BigDecimal.ZERO) == 0 ? zero :
                自费销售收入.divide(售后主营业务台次, 4, BigDecimal.ROUND_HALF_EVEN);
        entity.set平均单车自费售后产值(平均单车自费售后产值);

        BigDecimal 平均单车事故车售后产值 = 售后主营业务台次.compareTo(BigDecimal.ZERO) == 0 ? zero :
                事故车销售收入.divide(售后主营业务台次, 4, BigDecimal.ROUND_HALF_EVEN);
        entity.set平均单车事故车售后产值(平均单车事故车售后产值);

        BigDecimal 售后单车产值 = 售后主营业务台次.compareTo(BigDecimal.ZERO) == 0 ? zero :
                维修业务销售收入.divide(售后主营业务台次, 4, BigDecimal.ROUND_HALF_EVEN);
        entity.set售后单车产值(售后单车产值);

        BigDecimal 售后一级毛利率 = 维修业务销售收入.compareTo(BigDecimal.ZERO) == 0 ? zero :
                维修业务销售收入.subtract(维修业务材料成本).divide(维修业务销售收入, 4, BigDecimal.ROUND_HALF_EVEN);
        entity.set售后一级毛利率(售后一级毛利率);

        BigDecimal 售后二级毛利率 = 维修业务销售收入.compareTo(BigDecimal.ZERO) == 0 ? zero :
                维修业务销售收入.subtract(维修业务材料成本).add(维修业务返利).divide(维修业务销售收入, 4, BigDecimal.ROUND_HALF_EVEN);
        entity.set售后二级毛利率(售后二级毛利率);


        BigDecimal 售后三级毛利率 = 售后综合营业收入.compareTo(BigDecimal.ZERO) == 0 ? zero :
                维修业务销售收入.subtract(维修业务材料成本).add(维修业务返利).add(售后衍生收入).subtract(售后衍生成本)
                        .divide(售后综合营业收入, 4, BigDecimal.ROUND_HALF_EVEN);
        entity.set售后三级毛利率(售后三级毛利率);

        BigDecimal 索赔毛利贡献 = 售后综合营业收入.compareTo(BigDecimal.ZERO) == 0 ? zero :
                索赔销售收入.subtract(索赔材料成本).divide(售后综合营业收入, 4, BigDecimal.ROUND_HALF_EVEN);
        entity.set索赔毛利贡献(索赔毛利贡献);

        BigDecimal 保养毛利贡献 = 售后综合营业收入.compareTo(BigDecimal.ZERO) == 0 ? zero :
                保养销售收入.subtract(保养材料成本).divide(售后综合营业收入, 4, BigDecimal.ROUND_HALF_EVEN);
        entity.set保养毛利贡献(保养毛利贡献);

        BigDecimal 事故车毛利贡献 = 售后综合营业收入.compareTo(BigDecimal.ZERO) == 0 ? zero :
                事故车销售收入.subtract(事故车材料成本).divide(售后综合营业收入, 4, BigDecimal.ROUND_HALF_EVEN);
        entity.set事故车毛利贡献(事故车毛利贡献);

        BigDecimal 自费毛利贡献 = 售后综合营业收入.compareTo(BigDecimal.ZERO) == 0 ? zero :
                自费销售收入.subtract(自费材料成本).divide(售后综合营业收入, 4, BigDecimal.ROUND_HALF_EVEN);
        entity.set自费毛利贡献(自费毛利贡献);

        BigDecimal 售后毛利Ⅰ = 售后综合营业收入.compareTo(BigDecimal.ZERO) == 0 ? zero :
                维修业务销售收入.subtract(维修业务材料成本).divide(售后综合营业收入, 4, BigDecimal.ROUND_HALF_EVEN);
        entity.set售后毛利Ⅰ(售后毛利Ⅰ);

        BigDecimal 备件返利贡献 = 售后综合营业收入.compareTo(BigDecimal.ZERO) == 0 ? zero :
                维修业务返利.divide(售后综合营业收入, 4, BigDecimal.ROUND_HALF_EVEN);
        entity.set备件返利贡献(备件返利贡献);

        BigDecimal 售后毛利Ⅱ = 售后综合营业收入.compareTo(BigDecimal.ZERO) == 0 ? zero :
                维修业务销售收入.subtract(维修业务材料成本).add(维修业务返利).divide(售后综合营业收入, 4, BigDecimal.ROUND_HALF_EVEN);
        entity.set售后毛利Ⅱ(售后毛利Ⅱ);

        BigDecimal 售后保险衍生贡献 = 售后综合营业收入.compareTo(BigDecimal.ZERO) == 0 ? zero :
                维修业务保险收入.divide(售后综合营业收入, 4, BigDecimal.ROUND_HALF_EVEN);
        entity.set售后保险衍生贡献(售后保险衍生贡献);

        BigDecimal 售后精品备件衍生贡献 = 售后综合营业收入.compareTo(BigDecimal.ZERO) == 0 ?
                zero.subtract(售后保险衍生贡献) :
                售后衍生收入.subtract(售后衍生成本).divide(售后综合营业收入, 4, BigDecimal.ROUND_HALF_EVEN).subtract(售后保险衍生贡献);
        entity.set售后精品备件衍生贡献(售后精品备件衍生贡献);

        BigDecimal 平均单车索赔贡献 = 售后主营业务台次.compareTo(BigDecimal.ZERO) == 0 ? zero :
                索赔销售收入.subtract(索赔材料成本).divide(售后主营业务台次, 4, BigDecimal.ROUND_HALF_EVEN);
        entity.set平均单车索赔贡献(平均单车索赔贡献);

        BigDecimal 平均单车保养贡献 = 售后主营业务台次.compareTo(BigDecimal.ZERO) == 0 ? zero :
                保养销售收入.subtract(保养材料成本).divide(售后主营业务台次, 4, BigDecimal.ROUND_HALF_EVEN);
        entity.set平均单车保养贡献(平均单车保养贡献);

        BigDecimal 平均单车自费贡献 = 售后主营业务台次.compareTo(BigDecimal.ZERO) == 0 ? zero :
                自费销售收入.subtract(自费材料成本).divide(售后主营业务台次, 4, BigDecimal.ROUND_HALF_EVEN);
        entity.set平均单车自费贡献(平均单车自费贡献);

        BigDecimal 平均单车事故车贡献 = 售后主营业务台次.compareTo(BigDecimal.ZERO) == 0 ? zero :
                事故车销售收入.subtract(事故车材料成本).divide(售后主营业务台次, 4, BigDecimal.ROUND_HALF_EVEN);
        entity.set平均单车事故车贡献(平均单车事故车贡献);

        BigDecimal 平均单车售后毛利Ⅰ = 售后主营业务台次.compareTo(BigDecimal.ZERO) == 0 ? zero :
                维修业务销售收入.subtract(维修业务材料成本).divide(售后主营业务台次, 4, BigDecimal.ROUND_HALF_EVEN);
        entity.set平均单车售后毛利Ⅰ(平均单车售后毛利Ⅰ);

        BigDecimal 平均单车售后返利 = 售后主营业务台次.compareTo(BigDecimal.ZERO) == 0 ? zero :
                维修业务返利.divide(售后主营业务台次, 4, BigDecimal.ROUND_HALF_EVEN);
        entity.set平均单车售后返利(平均单车售后返利);

        BigDecimal 平均单车售后毛利Ⅱ = 售后主营业务台次.compareTo(BigDecimal.ZERO) == 0 ? zero :
                维修业务销售收入.subtract(维修业务材料成本).add(维修业务返利).divide(售后主营业务台次, 4, BigDecimal.ROUND_HALF_EVEN);
        entity.set平均单车售后毛利Ⅱ(平均单车售后毛利Ⅱ);

        BigDecimal 平均单车售后保险衍生 = 售后主营业务台次.compareTo(BigDecimal.ZERO) == 0 ? zero :
                维修业务保险收入.divide(售后主营业务台次, 4, BigDecimal.ROUND_HALF_EVEN);
        entity.set平均单车售后保险衍生(平均单车售后保险衍生);

        BigDecimal 平均单车售后精品备件衍生 = 售后主营业务台次.compareTo(BigDecimal.ZERO) == 0 ?
                zero.subtract(平均单车售后保险衍生) :
                售后衍生收入.subtract(售后衍生成本).divide(售后主营业务台次, 4, BigDecimal.ROUND_HALF_EVEN).subtract(平均单车售后保险衍生);
        entity.set平均单车售后精品备件衍生(平均单车售后精品备件衍生);

        BigDecimal 平均单车售后毛利Ⅲ = 售后主营业务台次.compareTo(BigDecimal.ZERO) == 0 ? zero :
                维修业务销售收入.subtract(维修业务材料成本).add(维修业务返利).add(售后衍生收入).subtract(售后衍生成本)
                        .divide(售后主营业务台次, 4, BigDecimal.ROUND_HALF_EVEN);
        entity.set平均单车售后毛利Ⅲ(平均单车售后毛利Ⅲ);

        BigDecimal 各项经营费用总计 = 各业务单元间接人工成本.add(各业务单元财务费用).add(各业务单元广告及市场费用).add(抵减后促销政策费用).add(其他可归属到业务的费用)
                .add(后勤管理部门的人工成本).add(后勤管理部门的财务费用).add(后勤管理部门的广告费用).add(折旧摊销费用).add(租赁费).add(培训差旅费).add(水电煤气费)
                .add(业务招待费).add(办公费).add(税金及附加).add(低值易耗品及物料消耗费).add(展厅车间设备维护费).add(保险费).add(审计咨询费).add(食堂费).add(集团管理费)
                .add(开办费待摊费用摊销).add(其他经营管理费用);

        BigDecimal 售后吸收率 = 各项经营费用总计.compareTo(BigDecimal.ZERO) == 0 ? zero :
                维修业务销售收入.subtract(售后销售成本).divide(各项经营费用总计, 4, BigDecimal.ROUND_HALF_EVEN);
        entity.set售后吸收率(售后吸收率);

        BigDecimal 索赔一级毛利率 = 索赔销售收入.compareTo(BigDecimal.ZERO) == 0 ? zero :
                索赔销售收入.subtract(索赔材料成本).divide(索赔销售收入, 4, BigDecimal.ROUND_HALF_EVEN);
        entity.set索赔一级毛利率(索赔一级毛利率);

        BigDecimal 保养一级毛利率 = 保养销售收入.compareTo(BigDecimal.ZERO) == 0 ? zero :
                保养销售收入.subtract(保养材料成本).divide(保养销售收入, 4, BigDecimal.ROUND_HALF_EVEN);
        entity.set保养一级毛利率(保养一级毛利率);

        BigDecimal 自费一级毛利率 = 自费销售收入.compareTo(BigDecimal.ZERO) == 0 ? zero :
                自费销售收入.subtract(自费材料成本).divide(自费销售收入, 4, BigDecimal.ROUND_HALF_EVEN);
        entity.set自费一级毛利率(自费一级毛利率);

        BigDecimal 事故车一级毛利率 = 事故车销售收入.compareTo(BigDecimal.ZERO) == 0 ? zero :
                事故车销售收入.subtract(事故车材料成本).divide(事故车销售收入, 4, BigDecimal.ROUND_HALF_EVEN);
        entity.set事故车一级毛利率(事故车一级毛利率);

        BigDecimal 售后业务毛利贡献率 = 综合营业收入.compareTo(BigDecimal.ZERO) == 0 ? zero :
                维修业务销售收入.subtract(维修业务材料成本).add(维修业务返利).divide(综合营业收入, 4, BigDecimal.ROUND_HALF_EVEN);
        entity.set售后业务毛利贡献率(售后业务毛利贡献率);

        BigDecimal 售后业务人工成本对售后利润贡献率 = 售后综合营业收入.compareTo(BigDecimal.ZERO) == 0 ? zero :
                维修业务各业务单元间接人工成本.add(维修业务工时成本).divide(售后综合营业收入, 4, BigDecimal.ROUND_HALF_EVEN);
        entity.set售后业务人工成本对售后利润贡献率(售后业务人工成本对售后利润贡献率);

        BigDecimal 售后业务市场费用对售后利润贡献率 = 售后综合营业收入.compareTo(BigDecimal.ZERO) == 0 ? zero :
                维修业务各业务单元广告及市场费用.divide(售后综合营业收入, 4, BigDecimal.ROUND_HALF_EVEN);
        entity.set售后业务市场费用对售后利润贡献率(售后业务市场费用对售后利润贡献率);

        BigDecimal 售后业务财务费用对售后利润贡献率 = 售后综合营业收入.compareTo(BigDecimal.ZERO) == 0 ? zero :
                维修业务各业务单元财务费用.divide(售后综合营业收入, 4, BigDecimal.ROUND_HALF_EVEN);
        entity.set售后业务财务费用对售后利润贡献率(售后业务财务费用对售后利润贡献率);

        BigDecimal 售后业务业务其他费用贡献 = 售后综合营业收入.compareTo(BigDecimal.ZERO) == 0 ? zero :
                维修业务抵减后促销政策费用.add(维修业务其他可归属到业务的费用).divide(售后综合营业收入, 4, BigDecimal.ROUND_HALF_EVEN);
        entity.set售后业务业务其他费用贡献(售后业务业务其他费用贡献);

        BigDecimal 售后利润贡献 = 售后三级毛利率.subtract(售后业务人工成本对售后利润贡献率).subtract(售后业务市场费用对售后利润贡献率)
                .subtract(售后业务财务费用对售后利润贡献率).subtract(售后业务业务其他费用贡献);
        entity.set售后利润贡献(售后利润贡献);


        //特殊处理
        if ("全国全年累计".equals(searchEnum.getSearchType()) || "大区全年累计".equals(searchEnum.getSearchType()) ||
                "经销商全年累计".equals(searchEnum.getSearchType())) {

            SearchEnum searchEnumSpec = SearchEnum.valueOf(searchEnum.getSearchType().substring(0, searchEnum.getSearchType().length() - 4));
            List<DealerForm> dealerCount = baseMap.get("dealerCount");

            BigDecimal 平均单店售后产值 = zero;
            BigDecimal 售后进厂台次平均单店 = zero;
            BigDecimal 平均单店索赔贡献 = zero;
            BigDecimal 平均单店保养贡献 = zero;
            BigDecimal 平均单店自费贡献 = zero;
            BigDecimal 平均单店事故车贡献 = zero;
            BigDecimal 平均单店售后毛利Ⅰ = zero;
            BigDecimal 平均单店售后返利 = zero;
            BigDecimal 平均单店售后毛利Ⅱ = zero;
            BigDecimal 平均单店售后保险衍生 = zero;
            BigDecimal 平均单店售后精品备件衍生 = zero;
            BigDecimal 平均单店售后毛利Ⅲ = zero;
            BigDecimal 平均单店索赔售后产值 = zero;
            BigDecimal 平均单店保养售后产值 = zero;
            BigDecimal 平均单店自费售后产值 = zero;
            BigDecimal 平均单店事故车售后产值 = zero;
            BigDecimal 平均单店索赔进厂台次 = zero;
            BigDecimal 平均单店保养进厂台次 = zero;
            BigDecimal 平均单店自费进厂台次 = zero;
            BigDecimal 平均单店事故车进厂台次 = zero;
            BigDecimal 平均单店售后人工成本含工时 = zero;
            BigDecimal 平均单店市场费用 = zero;
            BigDecimal 平均单店财务费用 = zero;
            BigDecimal 平均单店其他费用 = zero;
            BigDecimal 平均单店售后利润 = zero;
            BigDecimal 未被吸收的费用_平均单店 = zero;

            for (DealerForm form : dealerCount) {
                //获取经销商数量
                BigDecimal 当前季度经销商数量 = zero;
                String currentQuarter = form.getQuarterId();
                String currentDealer = dealerForm.getJxsDealerId();
                if ("全国".equals(searchEnumSpec.getSearchType())) {
                    当前季度经销商数量 = new BigDecimal(form.getDealerCount());

                } else if ("大区".equals(searchEnumSpec.getSearchType())) {
                    当前季度经销商数量 = new BigDecimal(
                            baseMap.get("regionDealerCount").stream().filter(
                                    x -> x.getQuarterId().equals(currentQuarter) && x.getRegionName().equals(regionEnum.getRegionName()))
                                    .collect(Collectors.toList()).get(0).getDealerCount());

                } else if ("经销商".equals(searchEnumSpec.getSearchType())) {
                    当前季度经销商数量 = new BigDecimal("1");

                }

                平均单店售后产值 = 平均单店售后产值.add(
                        getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.维修业务销售收入)
                                .divide(当前季度经销商数量, 4, BigDecimal.ROUND_HALF_EVEN));

                售后进厂台次平均单店 = 售后进厂台次平均单店.add(
                        getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.售后主营业务台次)
                                .divide(当前季度经销商数量, 4, BigDecimal.ROUND_HALF_EVEN));

                平均单店索赔贡献 = 平均单店索赔贡献.add(
                        getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.索赔销售收入)
                                .subtract(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.索赔材料成本))
                                .divide(当前季度经销商数量, 4, BigDecimal.ROUND_HALF_EVEN));

                平均单店保养贡献 = 平均单店保养贡献.add(
                        getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.保养销售收入)
                                .subtract(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.保养材料成本))
                                .divide(当前季度经销商数量, 4, BigDecimal.ROUND_HALF_EVEN));

                平均单店自费贡献 = 平均单店自费贡献.add(
                        getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.自费销售收入)
                                .subtract(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.自费材料成本))
                                .divide(当前季度经销商数量, 4, BigDecimal.ROUND_HALF_EVEN));

                平均单店事故车贡献 = 平均单店事故车贡献.add(
                        getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.事故车销售收入)
                                .subtract(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.事故车材料成本))
                                .divide(当前季度经销商数量, 4, BigDecimal.ROUND_HALF_EVEN));

                平均单店售后毛利Ⅰ = 平均单店售后毛利Ⅰ.add(
                        getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.维修业务销售收入)
                                .subtract(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.维修业务材料成本))
                                .divide(当前季度经销商数量, 4, BigDecimal.ROUND_HALF_EVEN));

                平均单店售后返利 = 平均单店售后返利.add(
                        getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.维修业务返利)
                                .divide(当前季度经销商数量, 4, BigDecimal.ROUND_HALF_EVEN));

                平均单店售后毛利Ⅱ = 平均单店售后毛利Ⅱ.add(
                        getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.维修业务销售收入)
                                .subtract(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.维修业务材料成本))
                                .add(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.维修业务返利))
                                .divide(当前季度经销商数量, 4, BigDecimal.ROUND_HALF_EVEN));

                平均单店售后保险衍生 = 平均单店售后保险衍生.add(
                        getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.售后业务保险收入)
                                .divide(当前季度经销商数量, 4, BigDecimal.ROUND_HALF_EVEN));

                BigDecimal temp = getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.售后业务保险收入)
                        .divide(当前季度经销商数量, 4, BigDecimal.ROUND_HALF_EVEN);

                平均单店售后精品备件衍生 = 平均单店售后精品备件衍生.add(
                        getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.售后衍生收入)
                                .subtract(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.售后衍生成本))
                                .divide(当前季度经销商数量, 4, BigDecimal.ROUND_HALF_EVEN)
                                .subtract(temp));

                平均单店售后毛利Ⅲ = 平均单店售后毛利Ⅲ.add(
                        getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.维修业务销售收入)
                                .subtract(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.维修业务材料成本))
                                .add(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.维修业务返利))
                                .add(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.售后衍生收入))
                                .subtract(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.售后衍生成本))
                                .divide(当前季度经销商数量, 4, BigDecimal.ROUND_HALF_EVEN));

                平均单店索赔售后产值 = 平均单店索赔售后产值.add(
                        getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.索赔销售收入)
                                .divide(当前季度经销商数量, 4, BigDecimal.ROUND_HALF_EVEN));

                平均单店保养售后产值 = 平均单店保养售后产值.add(
                        getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.保养销售收入)
                                .divide(当前季度经销商数量, 4, BigDecimal.ROUND_HALF_EVEN));

                平均单店自费售后产值 = 平均单店自费售后产值.add(
                        getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.自费销售收入)
                                .divide(当前季度经销商数量, 4, BigDecimal.ROUND_HALF_EVEN));

                平均单店事故车售后产值 = 平均单店事故车售后产值.add(
                        getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.事故车销售收入)
                                .divide(当前季度经销商数量, 4, BigDecimal.ROUND_HALF_EVEN));

                平均单店索赔进厂台次 = 平均单店索赔进厂台次.add(
                        getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.索赔主营业务台次)
                                .divide(当前季度经销商数量, 4, BigDecimal.ROUND_HALF_EVEN));

                平均单店保养进厂台次 = 平均单店保养进厂台次.add(
                        getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.保养主营业务台次)
                                .divide(当前季度经销商数量, 4, BigDecimal.ROUND_HALF_EVEN));

                平均单店自费进厂台次 = 平均单店自费进厂台次.add(
                        getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.自费主营业务台次)
                                .divide(当前季度经销商数量, 4, BigDecimal.ROUND_HALF_EVEN));

                平均单店事故车进厂台次 = 平均单店事故车进厂台次.add(
                        getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.事故车主营业务台次)
                                .divide(当前季度经销商数量, 4, BigDecimal.ROUND_HALF_EVEN));

                平均单店售后人工成本含工时 = 平均单店售后人工成本含工时.add(
                        getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.维修业务各业务单元间接人工成本)
                                .add(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.维修业务工时成本))
                                .divide(当前季度经销商数量, 4, BigDecimal.ROUND_HALF_EVEN));

                平均单店市场费用 = 平均单店市场费用.add(
                        getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.维修业务各业务单元广告及市场费用)
                                .divide(当前季度经销商数量, 4, BigDecimal.ROUND_HALF_EVEN));

                平均单店财务费用 = 平均单店财务费用.add(
                        getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.维修业务各业务单元财务费用)
                                .divide(当前季度经销商数量, 4, BigDecimal.ROUND_HALF_EVEN));

                平均单店其他费用 = 平均单店其他费用.add(
                        getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.维修业务抵减后促销政策费用)
                                .add(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.维修业务其他可归属到业务的费用))
                                .divide(当前季度经销商数量, 4, BigDecimal.ROUND_HALF_EVEN));

                平均单店售后利润 = 平均单店售后利润
                        .add(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.维修业务销售收入)
                                .subtract(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.维修业务材料成本))
                                .add(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.维修业务返利))
                                .add(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.售后衍生收入))
                                .subtract(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.售后衍生成本))
                                .divide(当前季度经销商数量, 4, BigDecimal.ROUND_HALF_EVEN))
                        .subtract(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.维修业务各业务单元间接人工成本)
                                .add(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.维修业务工时成本))
                                .divide(当前季度经销商数量, 4, BigDecimal.ROUND_HALF_EVEN))
                        .subtract(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.维修业务各业务单元广告及市场费用)
                                .divide(当前季度经销商数量, 4, BigDecimal.ROUND_HALF_EVEN))
                        .subtract(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.维修业务各业务单元财务费用)
                                .divide(当前季度经销商数量, 4, BigDecimal.ROUND_HALF_EVEN))
                        .subtract(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.维修业务抵减后促销政策费用)
                                .add(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.维修业务其他可归属到业务的费用))
                                .divide(当前季度经销商数量, 4, BigDecimal.ROUND_HALF_EVEN));

                未被吸收的费用_平均单店 = 未被吸收的费用_平均单店.add(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.维修业务销售收入)
                        .subtract(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.售后销售成本))
                        .subtract(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.各业务单元间接人工成本))
                        .subtract(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.各业务单元财务费用))
                        .subtract(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.各业务单元广告及市场费用))
                        .subtract(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.抵减后促销政策费用))
                        .subtract(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.其他可归属到业务的费用))
                        .subtract(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.后勤管理部门的人工成本))
                        .subtract(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.后勤管理部门的财务费用))
                        .subtract(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.后勤管理部门的广告费用))
                        .subtract(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.折旧摊销费用))
                        .subtract(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.租赁费))
                        .subtract(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.培训差旅费))
                        .subtract(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.水电煤气费))
                        .subtract(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.业务招待费))
                        .subtract(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.办公费))
                        .subtract(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.税金及附加))
                        .subtract(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.低值易耗品及物料消耗费))
                        .subtract(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.展厅车间设备维护费))
                        .subtract(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.保险费))
                        .subtract(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.审计咨询费))
                        .subtract(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.食堂费))
                        .subtract(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.集团管理费))
                        .subtract(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.开办费待摊费用摊销))
                        .subtract(getBaseIndex(yearId, currentQuarter, regionEnum, currentDealer, baseMap, searchEnumSpec, TargetEnum.其他经营管理费用))
                        .divide(当前季度经销商数量, 4, BigDecimal.ROUND_HALF_EVEN));


            }
            entity.set平均单店售后产值(平均单店售后产值);
            entity.set售后进厂台次平均单店(售后进厂台次平均单店);
            entity.set平均单店索赔贡献(平均单店索赔贡献);
            entity.set平均单店保养贡献(平均单店保养贡献);
            entity.set平均单店自费贡献(平均单店自费贡献);
            entity.set平均单店事故车贡献(平均单店事故车贡献);
            entity.set平均单店售后毛利Ⅰ(平均单店售后毛利Ⅰ);
            entity.set平均单店售后返利(平均单店售后返利);
            entity.set平均单店售后毛利Ⅱ(平均单店售后毛利Ⅱ);
            entity.set平均单店售后保险衍生(平均单店售后保险衍生);
            entity.set平均单店售后精品备件衍生(平均单店售后精品备件衍生);
            entity.set平均单店售后毛利Ⅲ(平均单店售后毛利Ⅲ);
            entity.set平均单店索赔售后产值(平均单店索赔售后产值);
            entity.set平均单店保养售后产值(平均单店保养售后产值);
            entity.set平均单店自费售后产值(平均单店自费售后产值);
            entity.set平均单店事故车售后产值(平均单店事故车售后产值);
            entity.set平均单店索赔进厂台次(平均单店索赔进厂台次);
            entity.set平均单店保养进厂台次(平均单店保养进厂台次);
            entity.set平均单店自费进厂台次(平均单店自费进厂台次);
            entity.set平均单店事故车进厂台次(平均单店事故车进厂台次);
            entity.set平均单店售后人工成本含工时(平均单店售后人工成本含工时);
            entity.set平均单店市场费用(平均单店市场费用);
            entity.set平均单店财务费用(平均单店财务费用);
            entity.set平均单店其他费用(平均单店其他费用);
            entity.set平均单店售后利润(平均单店售后利润);
            entity.set未被吸收的费用_平均单店(未被吸收的费用_平均单店);

        } else {
            BigDecimal 本季度经销商数量 = zero;

            if ("全国".equals(searchEnum.getSearchType())) {
                本季度经销商数量 = new BigDecimal(baseMap.get("dealerCount").stream().filter(
                        x -> x.getQuarterId().equals(quarterId))
                        .collect(Collectors.toList()).get(0).getDealerCount());

            } else if ("大区".equals(searchEnum.getSearchType())) {
                本季度经销商数量 = new BigDecimal(baseMap.get("regionDealerCount").stream().filter(
                        x -> x.getQuarterId().equals(quarterId) && x.getRegionName().equals(regionEnum.getRegionName()))
                        .collect(Collectors.toList()).get(0).getDealerCount());

            } else if ("经销商".equals(searchEnum.getSearchType())) {
                本季度经销商数量 = new BigDecimal("1");

            }

            BigDecimal 平均单店售后衍生业务收入 = 本季度经销商数量.compareTo(BigDecimal.ZERO) == 0 ? zero :
                    售后衍生收入.divide(本季度经销商数量, 4, BigDecimal.ROUND_HALF_EVEN);
            entity.set平均单店售后衍生业务收入(平均单店售后衍生业务收入);

            BigDecimal 平均单店售后产值 = 本季度经销商数量.compareTo(BigDecimal.ZERO) == 0 ? zero :
                    维修业务销售收入.divide(本季度经销商数量, 4, BigDecimal.ROUND_HALF_EVEN);
            entity.set平均单店售后产值(平均单店售后产值);

            BigDecimal 售后进厂台次平均单店 = 本季度经销商数量.compareTo(BigDecimal.ZERO) == 0 ? zero :
                    售后主营业务台次.divide(本季度经销商数量, 4, BigDecimal.ROUND_HALF_EVEN);
            entity.set售后进厂台次平均单店(售后进厂台次平均单店);

            BigDecimal 平均单店索赔贡献 = 本季度经销商数量.compareTo(BigDecimal.ZERO) == 0 ? zero :
                    索赔销售收入.subtract(索赔材料成本).divide(本季度经销商数量, 4, BigDecimal.ROUND_HALF_EVEN);
            entity.set平均单店索赔贡献(平均单店索赔贡献);

            BigDecimal 平均单店保养贡献 = 本季度经销商数量.compareTo(BigDecimal.ZERO) == 0 ? zero :
                    保养销售收入.subtract(保养材料成本).divide(本季度经销商数量, 4, BigDecimal.ROUND_HALF_EVEN);
            entity.set平均单店保养贡献(平均单店保养贡献);

            BigDecimal 平均单店自费贡献 = 本季度经销商数量.compareTo(BigDecimal.ZERO) == 0 ? zero :
                    自费销售收入.subtract(自费材料成本).divide(本季度经销商数量, 4, BigDecimal.ROUND_HALF_EVEN);
            entity.set平均单店自费贡献(平均单店自费贡献);

            BigDecimal 平均单店事故车贡献 = 本季度经销商数量.compareTo(BigDecimal.ZERO) == 0 ? zero :
                    事故车销售收入.subtract(事故车材料成本).divide(本季度经销商数量, 4, BigDecimal.ROUND_HALF_EVEN);
            entity.set平均单店事故车贡献(平均单店事故车贡献);

            BigDecimal 平均单店售后毛利Ⅰ = 本季度经销商数量.compareTo(BigDecimal.ZERO) == 0 ? zero :
                    维修业务销售收入.subtract(维修业务材料成本).divide(本季度经销商数量, 4, BigDecimal.ROUND_HALF_EVEN);
            entity.set平均单店售后毛利Ⅰ(平均单店售后毛利Ⅰ);

            BigDecimal 平均单店售后返利 = 本季度经销商数量.compareTo(BigDecimal.ZERO) == 0 ? zero :
                    维修业务返利.divide(本季度经销商数量, 4, BigDecimal.ROUND_HALF_EVEN);
            entity.set平均单店售后返利(平均单店售后返利);

            BigDecimal 平均单店售后毛利Ⅱ = 本季度经销商数量.compareTo(BigDecimal.ZERO) == 0 ? zero :
                    维修业务销售收入.subtract(维修业务材料成本).add(维修业务返利).divide(本季度经销商数量, 4, BigDecimal.ROUND_HALF_EVEN);
            entity.set平均单店售后毛利Ⅱ(平均单店售后毛利Ⅱ);

            BigDecimal 平均单店售后保险衍生 = 本季度经销商数量.compareTo(BigDecimal.ZERO) == 0 ? zero :
                    售后业务保险收入.divide(本季度经销商数量, 4, BigDecimal.ROUND_HALF_EVEN);
            entity.set平均单店售后保险衍生(平均单店售后保险衍生);

            BigDecimal 平均单店售后精品备件衍生 = 本季度经销商数量.compareTo(BigDecimal.ZERO) == 0 ?
                    zero.subtract(平均单店售后保险衍生) :
                    售后衍生收入.subtract(售后衍生成本).divide(本季度经销商数量, 4, BigDecimal.ROUND_HALF_EVEN).subtract(平均单店售后保险衍生);
            entity.set平均单店售后精品备件衍生(平均单店售后精品备件衍生);

            BigDecimal 平均单店售后毛利Ⅲ = 本季度经销商数量.compareTo(BigDecimal.ZERO) == 0 ? zero :
                    维修业务销售收入.subtract(维修业务材料成本).add(维修业务返利).add(售后衍生收入).subtract(售后衍生成本)
                            .divide(本季度经销商数量, 4, BigDecimal.ROUND_HALF_EVEN);
            entity.set平均单店售后毛利Ⅲ(平均单店售后毛利Ⅲ);

            BigDecimal 平均单店索赔售后产值 = 本季度经销商数量.compareTo(BigDecimal.ZERO) == 0 ? zero :
                    索赔销售收入.divide(本季度经销商数量, 4, BigDecimal.ROUND_HALF_EVEN);
            entity.set平均单店索赔售后产值(平均单店索赔售后产值);

            BigDecimal 平均单店保养售后产值 = 本季度经销商数量.compareTo(BigDecimal.ZERO) == 0 ? zero :
                    保养销售收入.divide(本季度经销商数量, 4, BigDecimal.ROUND_HALF_EVEN);
            entity.set平均单店保养售后产值(平均单店保养售后产值);

            BigDecimal 平均单店自费售后产值 = 本季度经销商数量.compareTo(BigDecimal.ZERO) == 0 ? zero :
                    自费销售收入.divide(本季度经销商数量, 4, BigDecimal.ROUND_HALF_EVEN);
            entity.set平均单店自费售后产值(平均单店自费售后产值);

            BigDecimal 平均单店事故车售后产值 = 本季度经销商数量.compareTo(BigDecimal.ZERO) == 0 ? zero :
                    事故车销售收入.divide(本季度经销商数量, 4, BigDecimal.ROUND_HALF_EVEN);
            entity.set平均单店事故车售后产值(平均单店事故车售后产值);

            BigDecimal 平均单店索赔进厂台次 = 本季度经销商数量.compareTo(BigDecimal.ZERO) == 0 ? zero :
                    索赔主营业务台次.divide(本季度经销商数量, 4, BigDecimal.ROUND_HALF_EVEN);
            entity.set平均单店索赔进厂台次(平均单店索赔进厂台次);

            BigDecimal 平均单店保养进厂台次 = 本季度经销商数量.compareTo(BigDecimal.ZERO) == 0 ? zero :
                    保养主营业务台次.divide(本季度经销商数量, 4, BigDecimal.ROUND_HALF_EVEN);
            entity.set平均单店保养进厂台次(平均单店保养进厂台次);

            BigDecimal 平均单店自费进厂台次 = 本季度经销商数量.compareTo(BigDecimal.ZERO) == 0 ? zero :
                    自费主营业务台次.divide(本季度经销商数量, 4, BigDecimal.ROUND_HALF_EVEN);
            entity.set平均单店自费进厂台次(平均单店自费进厂台次);

            BigDecimal 平均单店事故车进厂台次 = 本季度经销商数量.compareTo(BigDecimal.ZERO) == 0 ? zero :
                    事故车主营业务台次.divide(本季度经销商数量, 4, BigDecimal.ROUND_HALF_EVEN);
            entity.set平均单店事故车进厂台次(平均单店事故车进厂台次);

            BigDecimal 平均单店售后人工成本含工时 = 本季度经销商数量.compareTo(BigDecimal.ZERO) == 0 ? zero :
                    维修业务各业务单元间接人工成本.add(维修业务工时成本)
                            .divide(本季度经销商数量, 4, BigDecimal.ROUND_HALF_EVEN);
            entity.set平均单店售后人工成本含工时(平均单店售后人工成本含工时);

            BigDecimal 平均单店市场费用 = 本季度经销商数量.compareTo(BigDecimal.ZERO) == 0 ? zero :
                    维修业务各业务单元广告及市场费用.divide(本季度经销商数量, 4, BigDecimal.ROUND_HALF_EVEN);
            entity.set平均单店市场费用(平均单店市场费用);

            BigDecimal 平均单店财务费用 = 本季度经销商数量.compareTo(BigDecimal.ZERO) == 0 ? zero :
                    维修业务各业务单元财务费用.divide(本季度经销商数量, 4, BigDecimal.ROUND_HALF_EVEN);
            entity.set平均单店财务费用(平均单店财务费用);

            BigDecimal 平均单店其他费用 = 本季度经销商数量.compareTo(BigDecimal.ZERO) == 0 ? zero :
                    维修业务抵减后促销政策费用.add(维修业务其他可归属到业务的费用).divide(本季度经销商数量, 4, BigDecimal.ROUND_HALF_EVEN);
            entity.set平均单店其他费用(平均单店其他费用);

            BigDecimal 未被吸收的费用_平均单店 = getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.维修业务销售收入)
                    .subtract(getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.售后销售成本))
                    .subtract(getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.各业务单元间接人工成本))
                    .subtract(getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.各业务单元财务费用))
                    .subtract(getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.各业务单元广告及市场费用))
                    .subtract(getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.抵减后促销政策费用))
                    .subtract(getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.其他可归属到业务的费用))
                    .subtract(getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.后勤管理部门的人工成本))
                    .subtract(getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.后勤管理部门的财务费用))
                    .subtract(getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.后勤管理部门的广告费用))
                    .subtract(getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.折旧摊销费用))
                    .subtract(getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.租赁费))
                    .subtract(getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.培训差旅费))
                    .subtract(getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.水电煤气费))
                    .subtract(getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.业务招待费))
                    .subtract(getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.办公费))
                    .subtract(getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.税金及附加))
                    .subtract(getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.低值易耗品及物料消耗费))
                    .subtract(getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.展厅车间设备维护费))
                    .subtract(getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.保险费))
                    .subtract(getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.审计咨询费))
                    .subtract(getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.食堂费))
                    .subtract(getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.集团管理费))
                    .subtract(getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.开办费待摊费用摊销))
                    .subtract(getBaseIndex(yearId, quarterId, regionEnum, dealerId, baseMap, searchEnum, TargetEnum.其他经营管理费用))
                    .divide(本季度经销商数量, 4, BigDecimal.ROUND_HALF_EVEN);
            entity.set未被吸收的费用_平均单店(未被吸收的费用_平均单店);


        }


        return entity;
    }


    @Override
    public Integer checkSyncData(String yearId, String quarterId) {
        //获取该季度经销商填报数据
        List<JxsWrWriteDealerForm> dealerForm = processingDao.queryBaseDataByDate(yearId, quarterId);
        if (dealerForm.size() > 0){
            //查询复核表该季度是否有数据
            List<String> batchIdList = dealerForm.stream().map(JxsWrWriteDealerForm::getDealerBatchId).distinct().collect(Collectors.toList());
            Integer deleteRows = processingDao.queryBaseDataByBatchId(batchIdList);

            return deleteRows;
        } else {
            return 0;
        }

    }

    @Override
    public void insertJxsWrExceLog(String classType, String message,String yearId, String quarterId) {
        //计算错误日志记录
         processingDao.insertJxsWrExceLog(classType, message, yearId, quarterId);

    }
}